c++ – C2440: ‘initializing’: cannot convert from ‘A’ to ‘A’

This code compiles and runs in Visual Studio 2017:

#include <string>
using std::cin;
using std::cout;

template<class T>
class A
{
public:
    A(T a);
   ~A() {}
#if 0
    A(const A<T>&);
#else
    A(A<T>&);
#endif

    T t;
};

template<class T>
A<T>::A(T a) : t(a) {}

template <class T>
#if 0
A<T>::A(const A<T>& a) 
#else
A<T>::A(A<T>& a)
#endif
{
    t = a.t;
    std::cout << "In A copy constructor.n";
}

int main()
{
    std::string s;
    
    A<int> a1(11);
    A<double> a2(2.71);
#if 0
    A<double> a3 = A<double>(a2);  //gives C2440 when copy constructor argument is not const.
                                   //compiler message is: 'initializing': cannot convert from 'A<double>' to 'A<double>'
#else    
    A<double> a3{a2};              //works when copy constructor argument is not const.
#endif
        
    std::cout << a3.t << "n";
    std::cout << "Press ENTER to exit.n";
    std::getline(std::cin, s);
}

When all the #if 0s are changed to #if 1s, it compiles and runs also. But when the first two #if 0s are left in place and the #if 0 in main() is changed to #if 1, the compilation fails with C2440: 'initializing': cannot convert from 'A<double>' to 'A<double>'.

This question has no answer to mine. According to cppreference.com, copy constructors with non-const arguments are possible:

A copy constructor of class T is a non-template constructor whose first parameter is T&‍, const T&‍, volatile T&‍, or const volatile T&‍, and either there are no other parameters, or the rest of the parameters all have default values.

and the copy constructor with the non-const argument works anyway when I write

A<double> a3{a2};

So why does initializing with

A<double> a3 = A<double>(a2);

not work when the argument of the copy constructor is not const?