How to construct a type trait that can tell if one type's private methods can be called in another type's constructor?

You need to make the call to foo() part of the declaration of the Fooer constructor and make the constructor SFINAE friendly. You can do this with a constructor template and a default template argument for requirements. This means that HasFoo only needs to check if a Fooer can be constructed with T and doesn't have to worry about the foo() function.

template <typename T>
struct Fooer {
  template <typename U, typename = std::void_t<
    decltype(std::declval<U &>().foo()),
    std::enable_if_t<std::is_same_v<T, U>>
  >>
  explicit Fooer(U &fooable) {
    fooable.foo();
  }
};

template <typename U>
Fooer(U &) -> Fooer<U>;

template <typename T>
struct HasFoo : std::bool_constant<
  std::is_constructible_v<Fooer<T>, T &>
> {};

struct Fooable {
private:
  void foo() {}

  friend struct Fooer<Fooable>;
};

struct NotFooable {};

static_assert(HasFoo<Fooable>::value);
static_assert(!HasFoo<NotFooable>::value);

The trouble here is that the constructor of Fooer is not "SFINAE-friendly". It has a requirement that Fooer can call fooable.foo(), but as far as C++ is concerned, the declaration Fooer(T &); doesn't have any such constraint.

We can change the constructor declaration into a constructor template so that template argument deduction fails for it when the template argument of the class template is not "fooable":

#include <utility>

template <typename T>
struct Fooer
{
    template <typename U = T, typename Enable =
                std::void_t<decltype(std::declval<U&>().foo())>>
    Fooer (T & fooable)
    {
        fooable . foo ();
    }
};

[This will become easier and more legible with C++20 constraints:

// C++20 code
template <typename T>
struct Fooer
{
     Fooer (T & fooable) requires requires { fooable.foo(); }
     {
         fooable . foo ();
     }
};

]

With that change, your CanMakeFooer should work. Though it could be defined more simply with just the primary template and no specializations:

template <typename T>
struct CanMakeFooer :
    public std::bool_constant<std::is_constructible_v<Fooer<T>, T&>>
{};

Demo on coliru.