SFINAE неразрешимая перегрузка

Из комментария к вопросу, правильный подход - проверить "выражение вызова" (а не существование метода).

Следовательно, улучшение структура черты может быть следующим:

#include <type_traits>

template <typename T, typename U, typename = std::void_t<>>
struct hasCount : std::false_type {};

template <typename T, typename U>
struct hasCount<T, U, std::void_t<decltype(std::declval<T>().count(std::declval<U>()))>> : 
  std::true_type {};

Учитывая два экземпляра t и u типов соответственно T и U, он проверяет, допустимо ли выражение t.count(u).

Следовательно, следующий код действителен:

static_assert(hasCount<std::set<int>, int>::value);

Решение проблемы в вопросе.

Дополнительные замечания

Общий алгоритм теперь может быть реализован с помощью:

#include <algorithm>
#include <iterator>

template <typename Container, typename Element>
constexpr bool hasElement(const Container& c, const Element& e) {
  if constexpr (hasCount<Container, Element>::value) {
    return c.count(e);
  } else {
    return std::find(std::cbegin(c), std::cend(c), e) != std::cend(c);
  }
}

is there a way to solve the automatic overload?

Да, если вы знаете типы аргументов, передаваемых методу. В вашем случае, если я правильно понял, Element.

Ваш ответ покажет, как решить проблему, изменив исходный код. Далее я предлагаю решение на основе только заявленных функций constexpr.

is there another way to write a better hasCount trait?

Не знаю, лучше ли, но обычно я предпочитаю использовать функции constexpr.

Что-то вроде (Внимание: код не протестированпроверено прямо из ОП)

template <typename...>
constexpr std::false_type hasCountF (...);

template <typename T, typename ... As>
constexpr auto hasCountF (int)
   -> decltype( std::declval<T>().count(std::declval<As>()...), std::true_type{});

template <typename ... Ts>
using has_count = decltype(hasCountF<Ts...>(1));

а может и еще (только из C++ 14)

template <typename ... Ts>
constexpr auto has_count_v = has_count<Ts...>::value:

и вы можете назвать это следующим образом

if constexpr ( has_count_v<Container, Element> ) 

В вашем случае, используя Containerc и Elemente в вашей функции, вы можете упростить ее (избегая большого количества std::declval()), и вы можете попробовать с парой функций следующим образом

template <typename...>
constexpr std::false_type hasCountF (...);

template <typename C, typename ... As>
constexpr auto hasCountF (C const & c, As const & ... as)
   -> decltype( c.count(as...), std::true_type{});

называя это следующим образом

if constexpr ( decltype(hasCountF(c, e))::value )

но я предпочитаю предыдущее решение, потому что требуется больше машинописного ввода, но оно более гибкое.

В таких местах полезно просто перейти к отдельному набору перегрузки, у которого есть резерв:

template <typename Container, typename Element>
constexpr auto hasElement_impl(int, const Container& c, const Element& e) 
    -> decltype(c.count(e))
{
    return c.count(e);
}

template <typename Container, typename Element>
constexpr bool hasElement_impl(long, const Container& c, const Element& e) 
{
    return std::find(c.begin(), c.end(), e) != c.end();
}

template <typename Container, typename Element>
constexpr bool hasElement(const Container& c, const Element& e) 
{
    return hasElement_impl(0, c, e);
}

Если вы можете сделать c.count(e), сделайте это. В противном случае вернитесь к find(). В этом случае вам не нужно писать признак типа, и, действительно, сам вопрос демонстрирует проблему с попыткой пойти по этому пути. Гораздо проще не делать этого.

В качестве альтернативы, используя что-то вроде Boost.HOF:

constexpr inline auto hasElement = boost::hof::first_of(
    [](auto const& cnt, auto const& elem) BOOST_HOF_RETURNS(cnt.count(elem)),
    [](auto const& cnt, auto const& elem) {
        return std::find(cnt.begin(), cnt.end(), elem) != cnt.end();
    }
);

В C++ 20 такая доработка алгоритмов будет намного проще благодаря концепциям:

template <AssociativeContainer C, typename E>
bool hasElement(const C& c, const E& e) { return c.count(e); }

template <typename C, typename E>
bool hasElement(const C& c, const E& e) { return std::find(c.begin(), c.end(), e) != c.end(); }