Why compilers generate a copy/move constructors when there is a templated constructor?

Mechanism for this is well explained here: Template "copy constructor" does not prevent compiler-generated move constructor, but I would like to better undestand why it is made this way. I understand that move constructor is not generated even if any other constructor is written by the programmer, because it is an indication that construction of object is non trivial and auto generated constructor will probably be wrong. Then why templated constructors that have the same signature as copy constructors are not simply named copy constructors?

Example:

class Person {
 public:
  template<typename T>
    Person(T&& t) : s(std::forward<T>(t)) {
      std::cout << __PRETTY_FUNCTION__ << "\n";
    }

  Person(int n) {
    std::cout << __PRETTY_FUNCTION__ << "\n";
  }

  // No need to declare copy/move constructors as compiler will do this implicitly
  // Templated constructor does not inhibit it.
  //Person(const Person&) = default;
  //Person(Person&&) = default;

 private:
  std::string s;
};

and then:

Person p("asd");        // OK!
//Person p4(p);         // error as Person(T&&) is a better match

if I make p const:

const Person p("asd");
Person p4(p);           // thats ok, generator constructor is a better match

but if I explicitly delete even a move constructor with:

Person(Person&&) = delete;

then auto generation of constructors is inhibited.