Fix LuceneDev2000 codefix to insert IFormatProvider before out arg

TryParse signatures place the IFormatProvider before the trailing `out`
parameter (e.g. `bool TryParse(string, IFormatProvider, out double)`),
not at the end. The codefix was appending, producing a call that did
not bind to any overload.

Adds a regression test that fixes `double.TryParse("1.5", out _)` and
expects the provider to land in the correct slot.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: paulirwin

src/Lucene.Net.CodeAnalysis.Dev.CodeFixes/LuceneDev2xxx/LuceneDev2000_2001_2002_2004_AddInvariantCultureCodeFixProvider.cs

@@ -81,7 +81,15 @@ private static async Task<Document> AddCultureArgumentAsync(
                 SyntaxFactory.IdentifierName(cultureMember));
             var newArg = SyntaxFactory.Argument(cultureExpr);
 
-            var newInvocation = invocation.WithArgumentList(invocation.ArgumentList.AddArguments(newArg));
+            // For TryParse-style methods, the IFormatProvider must come BEFORE the trailing
+            // `out` argument: bool TryParse(string, IFormatProvider, out T). Otherwise append.
+            var args = invocation.ArgumentList.Arguments;
+            int insertAt = args.Count;
+            if (args.Count > 0 && args[args.Count - 1].RefKindKeyword.IsKind(SyntaxKind.OutKeyword))
+                insertAt = args.Count - 1;
+
+            var newArgs = args.Insert(insertAt, newArg);
+            var newInvocation = invocation.WithArgumentList(invocation.ArgumentList.WithArguments(newArgs));
             var newRoot = EnsureGlobalizationUsing(root).ReplaceNode(invocation, newInvocation);
             return document.WithSyntaxRoot(newRoot);
         }

tests/Lucene.Net.CodeAnalysis.Dev.CodeFixes.Tests/LuceneDev2xxx/TestLuceneDev2000_2001_2002_2004_AddInvariantCultureCodeFixProvider.cs

@@ -100,5 +100,44 @@ public class Sample
             };
             await test.RunAsync();
         }
+
+        [Test]
+        public async Task DoubleTryParse_InsertsInvariantCultureBeforeOutArg()
+        {
+            // Regression: TryParse signature is (string, IFormatProvider, out T) — the provider
+            // must be inserted BEFORE the trailing `out` parameter, not appended at the end.
+            var testCode = @"
+public class Sample
+{
+    public bool M() => double.TryParse(""1.5"", out _);
+}";
+
+            var fixedCode = @"using System.Globalization;
+
+public class Sample
+{
+    public bool M() => double.TryParse(""1.5"", CultureInfo.InvariantCulture, out _);
+}";
+
+            var expected = new DiagnosticResult(Descriptors.LuceneDev2000_BclNumericParseMissingFormatProvider)
+                .WithSeverity(DiagnosticSeverity.Warning)
+                .WithMessageFormat(Descriptors.LuceneDev2000_BclNumericParseMissingFormatProvider.MessageFormat)
+                .WithArguments("TryParse", "Double")
+                .WithLocation("/0/Test0.cs", line: 4, column: 31);
+
+            var test = new InjectableCodeFixTest(
+                () => new LuceneDev2000_BclNumericParseAnalyzer(),
+                () => new LuceneDev2000_2001_2002_2004_AddInvariantCultureCodeFixProvider())
+            {
+                TestCode = testCode,
+                FixedCode = fixedCode,
+                ReferenceAssemblies = ReferenceAssemblies.Net.Net80,
+                ExpectedDiagnostics = { expected },
+                CodeActionEquivalenceKey = "Add CultureInfo.InvariantCulture",
+                NumberOfIncrementalIterations = 2,
+                NumberOfFixAllIterations = 2
+            };
+            await test.RunAsync();
+        }
     }
 }