Различие SFINAE между подписанным и неподписанным

Если это не сработает, значит, ваш компилятор ошибся.

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

Это самое важное правило, которое следует здесь учитывать (опуская детали "..."). Два ваших шаблона не удовлетворяют ODR, потому что их последовательности токенов различаются.

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

Таким образом, ваши два шаблона определяют разные шаблоны и не конфликтуют. Теперь вы можете проверить, являются ли ваши шаблоны «функционально эквивалентными». Они были бы такими, если бы для любого возможного набора аргументов шаблона ваше выражение enable_if всегда давало бы одно и то же значение. Но так как это неверно для is_unsigned и is_signed, то и это не так. Если бы это было так, то ваш код был бы неправильно сформирован, но без диагностики (что фактически означает «неопределенное поведение»).

Лично я бы избегал SFINAE здесь, насколько это возможно, поскольку вы можете сделать то же самое с перегрузкой:

template<typename T>
uint16_t to_half_impl(T val, std::true_type, std::true_type)
{
    // is_integral + is_signed implementation
}

template<typename T>
uint16_t to_half_impl(T val, std::true_type, std::false_type)
{
    // is_integral + is_unsigned implementation
}

template<typename T>
uint16_t to_half_impl(T val, std::false_type, std::true_type)
{
    // is_floating_point implementation
}

template<typename T>
typename std::enable_if<std::is_arithmetic<T>::value, uint16_t>::type to_half(T val)
{
    return to_half_impl(val, std::is_integral<T>(), std::is_signed<T>());
}

Более распространенной идиомой является использование SFINAE для типа возвращаемого значения, а не для типа аргумента. В противном случае тип шаблона T может оказаться невыводимым. С участием

// from C++14
template<bool C, typename T> using enable_if_t = typename std::enable_if<C,T>::type;

template<typename T>
enable_if_t<std::is_integral<T>::value &&  std::is_signed<T>::value, uint16_t>
to_half(T value)
{
    //signed to half conversion
}

template<typename T>
enable_if_t<std::is_integral<T>::value && !std::is_signed<T>::value,  int16_t>
to_half(T value)
{
    //unsigned to half conversion
}

тип T в следующем выражении

auto y=to_half(x);    // T is deduced from argument, no need for <T> 

можно вывести (даже тривиально), но для вашего исходного кода это не так! Действительно, при запуске этого оператора с вашей реализацией to_half() через clang выдает

test.cc:24:11: error: no matching function for call to 'to_half'
  auto x= to_half(4);
          ^~~~~~~
test.cc:7:10: note: candidate template ignored: couldn't infer template argument 'T'
uint16_t to_half(typename std::enable_if<std::is_integral<T>::value &&
         ^
test.cc:15:10: note: candidate template ignored: couldn't infer template argument 'T'
uint16_t to_half(typename std::enable_if<std::is_integral<T>::value &&
         ^

Конечно, если явно указать аргумент шаблона (как вы сделали), эта проблема не возникает. Итак, ваш код не был неправильным (но компилятор), но какой смысл в SFINAE, если вы передаете тип аргумента шаблона?