Взаимодействие между шаблонами и перегрузками

Вывод следующего кода — TA, но я не понимаю, почему.

#include <iostream>
#include <type_traits>

struct A {};

template<typename T>
void fun(T) {
    std::cout << "T";
}

template<typename T>
void caller(T t) {
    fun(A{});
    fun(t);
}

void fun(A) {
    std::cout << "A";
}

int main() {
    caller(A{});
}

Мое понимание шаблонов говорит мне следующее:

• непосредственно перед разбором тела main единственная функция «на месте» — это нешаблонная перегрузка fun, та, что печатает A, потому что шаблоны fun и caller не использовались и, в свою очередь, не создавались экземпляры;
• только когда вызов caller анализируется, шаблон caller создается с помощью T = A, что подразумевает, что caller вызывает fun с объектами одного типа в обоих случаях;
• кроме того, поскольку этот тип — A, я бы сказал, что в обоих случаях вызывается нешаблонная перегрузка fun.

Однако вышесказанное неверно, иначе я бы получил AA (на самом деле, тоже TT меня меньше удивил бы, чем TA).

Я также заметил, что при перемещении нешаблонной перегрузки перед определением caller вывод становится AA, поэтому я могу только предположить:

• когда синтаксический анализатор читает строку fun(A{});, шаблон fun создается с помощью T = A, даже если шаблон caller еще не создается;
• затем, когда caller(A{}); анализируется, создается экземпляр caller;
• только в этот момент второй вызов fun в теле caller может быть интерпретирован как вызов с аргументом типа A, но на этот раз нешаблон fun уже известен компилятору, поэтому он выбран как лучшее соответствие.

Я не знаю, имеет ли смысл вышеизложенное.

Более предсказуемо, если я использую следующую специализацию шаблона

template<>
void fun<A>(A) {
    std::cout << "A";
}

вместо перегрузки без шаблона вывод всегда будет AA, независимо от того, поместил ли я специализацию до или после определения caller.