Combine auth initialization with config query

Add TryInitializeAndQueryGVFSConfig to GitAuthentication that merges
the anonymous probe, credential fetch, and config query into a single
flow. Instead of 3 HTTP requests (anonymous probe, then credential
fetch, then authenticated config query with a new HttpClient), this
makes at most 2 (or 1 for anonymous repos) reusing the same connection.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: tyrielv

GVFS/GVFS.Common/Git/GitAuthentication.cs

@@ -210,6 +210,76 @@ public bool TryInitialize(ITracer tracer, Enlistment enlistment, out string erro
             return true;
         }
 
+        /// <summary>
+        /// Combines authentication initialization with the GVFS config query,
+        /// eliminating the redundant anonymous probe HTTP request. Instead of:
+        ///   1. Anonymous probe → /gvfs/config → 401  (TryInitialize)
+        ///   2. Credential fetch                       (TryInitialize)
+        ///   3. Config query → /gvfs/config → 200     (QueryGVFSConfig)
+        /// This method does:
+        ///   1. Config query → /gvfs/config → 401 or 200
+        ///   2. If 401: credential fetch, then retry → 200
+        /// Saving one HTTP round-trip and reusing the same TCP/TLS connection.
+        /// </summary>
+        public bool TryInitializeAndQueryGVFSConfig(
+            ITracer tracer,
+            Enlistment enlistment,
+            RetryConfig retryConfig,
+            out ServerGVFSConfig serverGVFSConfig,
+            out string errorMessage)
+        {
+            if (this.isInitialized)
+            {
+                throw new InvalidOperationException("Already initialized");
+            }
+
+            serverGVFSConfig = null;
+            errorMessage = null;
+
+            using (ConfigHttpRequestor configRequestor = new ConfigHttpRequestor(tracer, enlistment, retryConfig))
+            {
+                HttpStatusCode? httpStatus;
+
+                // First attempt without credentials. If anonymous access works,
+                // we get the config in a single request.
+                if (configRequestor.TryQueryGVFSConfig(false, out serverGVFSConfig, out httpStatus, out _))
+                {
+                    this.IsAnonymous = true;
+                    this.isInitialized = true;
+                    tracer.RelatedInfo("{0}: Anonymous access succeeded, config obtained in one request", nameof(this.TryInitializeAndQueryGVFSConfig));
+                    return true;
+                }
+
+                if (httpStatus != HttpStatusCode.Unauthorized)
+                {
+                    errorMessage = "Unable to query /gvfs/config";
+                    tracer.RelatedWarning("{0}: Config query failed with status {1}", nameof(this.TryInitializeAndQueryGVFSConfig), httpStatus?.ToString() ?? "None");
+                    return false;
+                }
+
+                // Server requires authentication — fetch credentials
+                this.IsAnonymous = false;
+
+                if (!this.TryCallGitCredential(tracer, out errorMessage))
+                {
+                    tracer.RelatedWarning("{0}: Credential fetch failed: {1}", nameof(this.TryInitializeAndQueryGVFSConfig), errorMessage);
+                    return false;
+                }
+
+                this.isInitialized = true;
+
+                // Retry with credentials using the same ConfigHttpRequestor (reuses HttpClient/connection)
+                if (configRequestor.TryQueryGVFSConfig(true, out serverGVFSConfig, out _, out errorMessage))
+                {
+                    tracer.RelatedInfo("{0}: Config obtained with credentials", nameof(this.TryInitializeAndQueryGVFSConfig));
+                    return true;
+                }
+
+                tracer.RelatedWarning("{0}: Config query failed with credentials: {1}", nameof(this.TryInitializeAndQueryGVFSConfig), errorMessage);
+                return false;
+            }
+        }
+
         public bool TryInitializeAndRequireAuth(ITracer tracer, out string errorMessage)
         {
             if (this.isInitialized)

GVFS/GVFS.Mount/InProcessMount.cs

@@ -88,21 +88,34 @@ public void Mount(EventLevel verbosity, Keywords keywords)
             // Start auth + config query immediately — these are network-bound and don't
             // depend on repo metadata or cache paths. Every millisecond of network latency
             // we can overlap with local I/O is a win.
+            // TryInitializeAndQueryGVFSConfig combines the anonymous probe, credential fetch,
+            // and config query into at most 2 HTTP requests (1 for anonymous repos), reusing
+            // the same HttpClient/TCP connection.
             Stopwatch parallelTimer = Stopwatch.StartNew();
 
             var networkTask = Task.Run(() =>
             {
                 Stopwatch sw = Stopwatch.StartNew();
-                string authError;
-                if (!this.enlistment.Authentication.TryInitialize(this.tracer, this.enlistment, out authError))
+                ServerGVFSConfig config;
+                string authConfigError;
+
+                if (!this.enlistment.Authentication.TryInitializeAndQueryGVFSConfig(
+                    this.tracer, this.enlistment, this.retryConfig,
+                    out config, out authConfigError))
                 {
-                    this.tracer.RelatedWarning("Mount will proceed, but new files cannot be accessed until GVFS can authenticate: " + authError);
+                    if (this.cacheServer != null && !string.IsNullOrWhiteSpace(this.cacheServer.Url))
+                    {
+                        this.tracer.RelatedWarning("Mount will proceed with fallback cache server: " + authConfigError);
+                        config = null;
+                    }
+                    else
+                    {
+                        this.FailMountAndExit("Unable to query /gvfs/config" + Environment.NewLine + authConfigError);
+                    }
                 }
 
-                this.tracer.RelatedInfo("ParallelMount: Auth completed in {0}ms", sw.ElapsedMilliseconds);
-
-                ServerGVFSConfig config = this.QueryAndValidateGVFSConfig();
-                this.tracer.RelatedInfo("ParallelMount: Auth + config query completed in {0}ms", sw.ElapsedMilliseconds);
+                this.ValidateGVFSVersion(config);
+                this.tracer.RelatedInfo("ParallelMount: Auth + config completed in {0}ms", sw.ElapsedMilliseconds);
                 return config;
             });