[AST] Consider QualifiedTemplateName in TemplateName::getAsUsingDecl().

[hokein]

Summary

If the underlying template name of a qualified template name is a using
decl, TemplateName::getAsUsingDecl() will return it.

This will make the UsingTemplateName consumer life easier.

[hokein]

Fix the broken test.

clang-tools-extra/clangd/unittests/IncludeCleanerTests.cpp

TestCase Cases[] = {
       },
       {"namespace ns { template<typename T> class A {}; } using ns::^A;",
        "A<int>* a;"},
       {"namespace ns { template<typename T> class A {}; } using ns::^A;",
        R"cpp(
           template <template <typename> class T> class X {};
           X<A> x;
         )cpp"},
+      {R"cpp(namespace ns { template<typename T> class A {};
+         namespace absl {using ns::^A;}
+       )cpp",
+       R"cpp(
+          template <template <typename> class T> class X {};
+          X<absl::A> x;
+       )cpp"},
       {R"cpp(
           namespace ns { template<typename T> struct ^A { ^A(T); }; }
           using ns::^A;
        )cpp",
        "A CATD(123);"},
       {
           "typedef bool ^Y; template <typename T> struct ^X {};",
           "X<Y> x;",

clang/lib/AST/TemplateName.cpp

 DependentTemplateName *TemplateName::getAsDependentTemplateName() const {
   return Storage.dyn_cast<DependentTemplateName *>();
 }
 
 UsingShadowDecl *TemplateName::getAsUsingShadowDecl() const {
   if (Decl *D = Storage.dyn_cast<Decl *>())
     if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D))
       return USD;
+  if (QualifiedTemplateName *QTN = getAsQualifiedTemplateName())
+    return QTN->getUnderlyingTemplate().getAsUsingShadowDecl();
   return nullptr;
 }
 
 TemplateName TemplateName::getNameToSubstitute() const {
   TemplateDecl *Decl = getAsTemplateDecl();
 
   // Substituting a dependent template name: preserve it as written.
   if (!Decl)

clang/unittests/AST/TemplateNameTest.cpp

TEST(TemplateName, QualifiedUsingTemplate) {
   ASSERT_TRUE(TAL);
   TemplateName TN = TAL->getArgument().getAsTemplate();
   EXPECT_EQ(TN.getKind(), TemplateName::QualifiedTemplate);
   const auto *QTN = TN.getAsQualifiedTemplateName();
   // Verify that we have the Using template name in the QualifiedTemplateName.
   const auto *USD = QTN->getUnderlyingTemplate().getAsUsingShadowDecl();
   EXPECT_TRUE(USD);
   EXPECT_EQ(USD->getTargetDecl(), TN.getAsTemplateDecl());
+  EXPECT_EQ(TN.getAsUsingShadowDecl(), USD);
 }
 
 TEST(TemplateName, UsingTemplate) {
   auto AST = tooling::buildASTFromCode(R"cpp(
     namespace std {
       template <typename T> struct vector { vector(T); };
     }
     namespace absl { using std::vector; }