这看起来像CWG1980（std::void_t<typename T::red>和std::void_t<typename T::blue>被认为是“等价的”，因为它们都是void，所以它们是重定义，但它们在功能上不等价，因为它们可以通过替换失败来区分）。
即使你要通过使它成为一个依赖的void来修复它，比如：

template<typename...> struct dependent_void { using type = void; };
template<typename... T> using dependent_void_t = typename dependent_void<T...>::type;

它会使这两个部分特化：

template <class T, class Void>
struct holder_type_of<T, dependent_void_t<typename T::red>, Void>
    : std::integral_constant<holder_type, holder_type::red> {};
template <class T>
struct holder_type_of<T, dependent_void_t<typename T::blue>, dependent_void_t<typename T::red>>
    : std::integral_constant<holder_type, holder_type::both> {};

因为中间参数dependent_void_t<typename T::red>和dependent_void_t<typename T::blue>是不相关的，并且不是一种或另一种方式更好。
...所以你可以翻转红色的参数，这样最后一个参数是相同的，dependent_void_t<typename T::blue>比Void更好。你甚至可以回到std::void_t，因为你不再用不同的模板参数比较多个std::void_t：

template <class T, class Void>
struct holder_type_of<T, Void, std::void_t<typename T::red>>
    : std::integral_constant<holder_type, holder_type::red> {};

https://godbolt.org/z/s6dPYWeao
在多种情况下，这很快就变得难以管理
基于“优先级”的SFINAE检测更容易通过函数重载完成，尽管：

// Lowest priority overload
template<typename T>
constexpr holder_type holder_type_of_impl(...) { return holder_type::none; }
template<typename T, std::void_t<typename T::red>* = nullptr>
constexpr holder_type holder_type_of_impl(void*) { return holder_type::red; }
template<typename T, std::void_t<typename T::blue>* = nullptr>
constexpr holder_type holder_type_of_impl(long) { return holder_type::blue; }
template<typename T, std::void_t<typename T::red, typename T::blue>* = nullptr>
constexpr holder_type holder_type_of_impl(int) { return holder_type::both; }
// Highest priority overload
template <class T>
struct holder_type_of
    : std::integral_constant<holder_type, ::holder_type_of_impl<T>(0)> {};
// And if you have more than 4 priorities (probably a sign to break up your checks),
// you can use this handy template
template<unsigned N> struct priority : priority<N-1u> {};
template<> struct priority<0> {};
// Ordered from worst to best match for `f(priority<6>{})`
void f(priority<0>);
void f(priority<1>);
void f(priority<2>);
void f(priority<3>);
void f(priority<4>);
void f(priority<5>);
void f(priority<6>);

代码的问题是由<T, void_t<>>的几个专门化引起的，这些专门化被评估为<T, void>，因此出现了重新定义错误。
为了避免这个问题，您需要对每个专门化进行一些消歧。基本上，我认为没有办法逃避为has_type编写专门化。
然而，使用标签可以使生活变得更容易。
下面是一个方便的API示例，它反映了您的人工示例中的用法：

#include <type_traits>
struct S {};
struct empty {};
struct red_holder {
    using red = S;
};
struct blue_holder {
    using blue = S;
};
struct both_holder {
    using red = S;
    using blue = S;
};
enum /*class*/ holder_type {
    none = 0,
    red = 1,
    blue = 2,
    both = 3
};
namespace tag 
{
    struct red_t {} constexpr red{};
    struct blue_t{} constexpr blue{};
}
template <typename Tag, typename T, typename = void>
struct _has : std::integral_constant<holder_type, holder_type::none>{};
template <typename T>
struct _has<tag::red_t, T, std::void_t<typename T::red>> 
    : std::integral_constant<holder_type, holder_type::red> {};
template <typename T>
struct _has<tag::blue_t, T, std::void_t<typename T::blue>> 
    : std::integral_constant<holder_type, holder_type::blue> {};
template <typename T, typename ... Tags>
constexpr holder_type has(Tags... tags) noexcept {
    const auto flags = (_has<Tags, T>{} | ...);
    return static_cast<holder_type>(flags);
}
template <typename T>
constexpr holder_type has() noexcept {
    return holder_type::none;
}
static_assert(has<empty>() == holder_type::none);
static_assert(has<red_holder>(tag::red) == holder_type::red);
static_assert(has<blue_holder>(tag::blue) == holder_type::blue);
static_assert(has<both_holder>(tag::red) == holder_type::red);
static_assert(has<both_holder>(tag::blue) == holder_type::blue);
static_assert(has<both_holder>(tag::blue, tag::red) == holder_type::both);

https://godbolt.org/z/qPax11GYf
因为（在我看来）你需要有类型->值Map，我建议使用标志。
使用标记减少了必要的样板文件。基本上，对于每个成员检测，您必须编写2个类模板（基本“假”+专门化）。
通过使用标记，您现在只需编写一个专门化。但是在我们有反射支持之前，你必须***编写它。