I was working with parameter packs when I noticed that one such case(given below) doesn't compile in msvc but compiles fine in gcc and clang. Here is the link for the verification of the same: link to demo

The code is as follows:

template<typename T> struct C{};

template<typename T> void f(C<T>)
{

}
template<typename... T> void f(C<T...>)
{

}
int main()
{
    f(C<int>{}); //Should this call succeed? 
}

I want to know if the above example is well-formed according to the standard. I mean should the call f(C<int>{}); succeed by choosing the first overload version `void f(C<T>)`  over the second version.

For possible explanation i looked at examples given in: temp.deduct.type#9.2:

[Example

template<class T1, class... Z> class S;                                 // #1
template<class T1, class... Z> class S<T1, const Z&...> { };            // #2
template<class T1, class T2>   class S<T1, const T2&> { };              // #3
S<int, const int&> s;           // both #2 and #3 match; #3 is more specialized

End Example]

My current understanding/intuition is that the example that I gave here should be valid as well and the first overload should be chosen over the second. 

If so, should this or a similar example be added in temp.deduct.type to make this more clear? 
Basically I want to know if the intention for the same(i.e., for allowing the example that i gave) was always there but was not clearly conveyed. If not, then is there a clause that clear disallows 

the example that i gave which i missed to notice/understand.