[temp.deduct.partial] p8 says

Using the resulting types P and A, the deduction is then done as described in [temp.deduct.type].

[temp.deduct.type] p1 says

an attempt is made to find template argument values (a type for a type parameter, a value for a non-type parameter, or a template for a template parameter) that will make P, after substitution of the deduced values (call it the deduced A), compatible with A.

[temp.func.order] p3 says

To produce the transformed template, for each type, non-type, or template template parameter (including template parameter packs thereof) synthesize a unique type, value, or class template respectively and substitute it for each occurrence of that parameter in the function type of the template.

Consider this example:

template<class T, class U>
struct A{};

template<class T>
void fun(A<T,T>){
    std::cout<<"#1\n";
}

template<class T>
void fun(A<T, std::remove_reference_t<decltype(std::declval<T>())>>){
     std::cout<<"#2\n";
}

Take #1 as the argument template and #2 as the parameter template. Assume the unique type for T in #1 is TUnique1, hence A is A<TUnique1, TUnique1>, which compares with P that is A<T, std::remove_reference_t<decltype(std::declval<T>())>>, the first T in P is deduced to TUnique1, according to [temp.deduct.type] p4, the second T in P uses the value deduced for the first T. Back to [temp.deduct.type] p1, the result of the substitution is A<TUnique1, TUnique1> because std::remove_reference_t<decltype(std::declval<T>())> is T for any type T. The deduction of P from A success. Again,take #1 as the parameter template and #2 as the argument template, with the similar reason, the deduction of P from A success. We expect the call would be ambiguous, however, most implementations chose #1.

Consider a contrast example:

template<class T>
struct Wrapper{
    using type = T;
};

template<class T, class U>
struct A{};

template<class T>
void fun(A<T, typename Wrapper<T>::type>){
    std::cout<<"#1\n";
}

template<class T>
void fun(A<T, std::remove_reference_t<decltype(std::declval<T>())>>){
     std::cout<<"#2\n";
}

For any type T, the result of the substitution of typename Wrapper<T>::type is T. The call is ambiguous for a similar reason as above, at this time, implementations agree the call is ambiguous. More vague in partial ordering can be found here
https://stackoverflow.com/questions/31394260/template-partial-ordering-why-does-partial-deduction-succeed-here
https://stackoverflow.com/questions/42416993/class-template-specialization-partial-ordering-and-function-synthesis

The subject of the second question can be simplified as

template<class T, class U>
struct A{};

// template<class T>
// struct A<T,T>{};

// template<class T>
// struct A<T, decltype(T{})>{};

template<class T>
void fun(A<T,T>){
    std::cout<<"#1\n";
}

template<class T>
void fun(A<T, decltype(T{})>){
    std::cout<<"#2\n";
}
int main(){
   // A<int,int> c;  
   fun(A<int,int>{});
}

The call prints #1 but A<int,int> is ambiguous. However, the partial ordering of the class partial specializations should be equivalent to partial ordering of the function templates.