Fix namespace matching and remove TypeKind.Error fallback in IsTestMethod

- Fix StartsWith bug: 'Xunit'.StartsWith('Xunit') would also match 'Xunit2Extensions'
  etc. Now uses exact match or dotted prefix check to prevent false positive suppression.
- Remove s_commonTestAttributeNames fallback: now that DiagnosticVerifier adds real
  framework assembly references to every test compilation, TypeKind.Error can no longer
  occur in tests. The fallback was also risky in production — any user-defined [Test]
  or [Fact] attribute in an unresolved assembly would incorrectly suppress INTL0003.
- Rename s_testFrameworkNamespaces -> _TestFrameworkNamespaces to comply with INTL0001.

Author: BenjaminMichaelis

IntelliTect.Analyzer/IntelliTect.Analyzer/Analyzers/NamingMethodPascal.cs

@@ -105,29 +105,17 @@ private static void AnalyzeSymbol(SymbolAnalysisContext context)
             context.ReportDiagnostic(diagnostic);
         }
 
-        // Test framework namespaces — any method decorated with an attribute from these namespaces
-        // is considered a test method and exempt from PascalCase validation.
+        // Test framework namespaces — any method decorated with an attribute whose namespace
+        // exactly matches or starts with one of these is exempt from PascalCase validation.
         // To add a new framework, append its root namespace here and update TestFrameworkReferences.cs.
-        private static readonly string[] s_testFrameworkNamespaces =
+        private static readonly string[] _TestFrameworkNamespaces =
         [
             "Xunit",                                         // xUnit (namespace is "Xunit", not "XUnit")
             "NUnit.Framework",                               // NUnit
             "Microsoft.VisualStudio.TestTools.UnitTesting",  // MSTest
             "TUnit.Core"                                     // TUnit
         ];
 
-        // Fallback attribute names for compilations without framework assembly references.
-        // Only used when the attribute type is unresolved (TypeKind.Error).
-        private static readonly string[] s_commonTestAttributeNames =
-        [
-            "TestMethod", "TestMethodAttribute",         // MSTest
-            "Fact", "FactAttribute",                     // xUnit
-            "Theory", "TheoryAttribute",                 // xUnit
-            "Test", "TestAttribute",                     // NUnit / TUnit
-            "TestCase", "TestCaseAttribute",             // NUnit
-            "TestCaseSource", "TestCaseSourceAttribute"  // NUnit
-        ];
-
         private static bool IsTestMethod(IMethodSymbol methodSymbol)
         {
             ImmutableArray<AttributeData> attributes = methodSymbol.GetAttributes();
@@ -138,22 +126,11 @@ private static bool IsTestMethod(IMethodSymbol methodSymbol)
                     return false;
                 }
 
-                // Check namespace first — works whenever the compilation includes real framework references.
-                string containingNamespace = attribute.AttributeClass.ContainingNamespace?.ToDisplayString();
-                if (containingNamespace != null &&
-                    s_testFrameworkNamespaces.Any(ns => containingNamespace.StartsWith(ns, StringComparison.Ordinal)))
-                {
-                    return true;
-                }
-
-                // Fallback: check by name only for unresolved types (missing assembly reference in compilation).
-                // Gated on TypeKind.Error to avoid false negatives for user-defined attributes with the same names.
-                if (attribute.AttributeClass.TypeKind == TypeKind.Error)
-                {
-                    return s_commonTestAttributeNames.Contains(attribute.AttributeClass.Name);
-                }
-
-                return false;
+                string? containingNamespace = attribute.AttributeClass.ContainingNamespace?.ToDisplayString();
+                return containingNamespace != null &&
+                    _TestFrameworkNamespaces.Any(ns =>
+                        string.Equals(containingNamespace, ns, StringComparison.Ordinal) ||
+                        containingNamespace.StartsWith(ns + ".", StringComparison.Ordinal));
             });
         }
     }