在

cout << toStr(a) << '\n';

将A类型的左值传递给toStr()。
它现在可以将其转换为const A&以匹配

const T& obj

或将其复制到A以进行匹配

T val

没有一个比另一个更专业，因此是模糊的。
请注意，A::toStr()应该是const，才能在string toStr(const T& obj)版本中使用。
然后你可以添加一些约束来选择正确的重载，比如检查类型是否有toStr成员函数：

template <class, class = void>
struct has_toStr : std::false_type {};

template <class T>
struct has_toStr<T, std::void_t<decltype(std::declval<T&>().toStr())> >
    : std::true_type {};

template <class T>
inline constexpr bool has_toStr_v = has_toStr<T>::value;

template <class T>
std::string toStr(const T& obj)
    requires has_toStr_v<T>
{
    return obj.toStr();
}

template <class T>
std::string toStr(T val)
    requires(not has_toStr_v<T>)
{
    return std::to_string(val);
}

按引用和按值参数不能用于消除重载的歧义。（最多可以使用不同类型的引用，例如：const T &与T &&，但在这里无关紧要。）
这里的问题是函数不是SFINA友好的（即，函数体对于特定T无效不足以在重载解析期间拒绝该重载）。
你需要明确地阐明这些条件，例如：使用requires：

template <typename T> 
std::string toStr(const T &obj)
requires requires{{obj.toStr()} -> std::convertible_to<std::string>;}
{
    return obj.toStr();
}

template <typename T>
requires std::is_arithmetic_v<T>
std::string toStr(T val)
{
    return std::to_string(val);
}

我还做了一些表面上的改变。您还必须const-限定A的toStr()。
在C++20之前，它看起来像这样：

template <
    typename T,
    std::enable_if_t<
        std::is_convertible_v<decltype(std::declval<const T &>().toStr()), std::string>,
        std::nullptr_t
    > = nullptr
> 
std::string toStr(const T &obj)
{
    return obj.toStr();
}

template <
    typename T,
    std::enable_if_t<std::is_arithmetic_v<T>, std::nullptr_t> = nullptr
> 
std::string toStr(T val)
{
    return std::to_string(val);
}

阅读完整的信息，而不仅仅是第一行：toStr(const A&): candidate与toStr(T val): candidate有歧义。
假设toStr(a)，你会如何选择？通过引用还是通过值传递？模棱两可。
试图通过使用static_cast<const A&>来强制类型不会改变任何东西，通过引用或通过值传递？
一般来说，不要重载带有pass-by-ref和匡威-value的函数，否则会导致歧义。