config: use --show-scope instead of --show-origin in cache

Context:
The config cache path already gates on Git 2.54.0+ (or microsoft/git
2.53.0.vfs.0.1+) to use 'git config list --type=<X>'. These versions
also support --show-scope, which directly reports the scope (system,
global, local) as a simple string rather than a file path.

Justification:
The --show-origin approach required heuristic path matching to guess
the scope from origin paths like 'file:/etc/gitconfig' or
'file:~/.gitconfig'. This was fragile: it could fail on non-standard
install prefixes or platform-specific paths (e.g., Windows). Since
--show-scope is available at the same Git versions we already require,
we can use it for reliable scope detection with no guesswork.

Implementation:
- Replace --show-origin with --show-scope in the git config list call
- Replace DetermineLevel() path heuristic with ParseScope() that does
  a direct string match on 'system', 'global', 'local'
- Remove the now-unused Origin property from ConfigCacheEntry
- Rename origin variables to scope throughout ConfigCache.Load()

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

Author: derrickstolee

src/shared/Core/GitConfiguration.cs

@@ -114,46 +114,33 @@ public interface IGitConfiguration
     /// </summary>
     internal class ConfigCacheEntry
     {
-        public string Origin { get; set; }
         public string Value { get; set; }
         public GitConfigurationLevel Level { get; set; }
 
-        public ConfigCacheEntry(string origin, string value)
+        public ConfigCacheEntry(string scope, string value)
         {
-            Origin = origin;
             Value = value;
-            Level = DetermineLevel(origin);
+            Level = ParseScope(scope);
         }
 
-        private static GitConfigurationLevel DetermineLevel(string origin)
+        private static GitConfigurationLevel ParseScope(string scope)
         {
-            if (string.IsNullOrEmpty(origin))
-                return GitConfigurationLevel.Unknown;
-
-            // Origins look like: "file:/path/to/config", "command line:", "standard input:"
-            if (!origin.StartsWith("file:"))
-                return GitConfigurationLevel.Unknown;
-
-            string path = origin.Substring(5); // Remove "file:" prefix
-
-            // System config is typically in /etc/gitconfig or $(prefix)/etc/gitconfig
-            if (path.Contains("/etc/gitconfig") || path.EndsWith("/gitconfig"))
-                return GitConfigurationLevel.System;
-
-            // Global config is typically in ~/.gitconfig or ~/.config/git/config
-            if (path.Contains("/.gitconfig") || path.Contains("/.config/git/config"))
-                return GitConfigurationLevel.Global;
-
-            // Local config is typically in .git/config within a repository
-            if (path.Contains("/.git/config"))
-                return GitConfigurationLevel.Local;
-
-            return GitConfigurationLevel.Unknown;
+            switch (scope)
+            {
+                case "system":
+                    return GitConfigurationLevel.System;
+                case "global":
+                    return GitConfigurationLevel.Global;
+                case "local":
+                    return GitConfigurationLevel.Local;
+                default:
+                    return GitConfigurationLevel.Unknown;
+            }
         }
     }
 
     /// <summary>
-    /// Cache for Git configuration entries loaded from 'git config list --show-origin -z'.
+    /// Cache for Git configuration entries loaded from 'git config list --show-scope -z'.
     /// </summary>
     internal class ConfigCache
     {
@@ -168,26 +155,26 @@ public void Load(string data, ITrace trace)
             {
                 var entries = new Dictionary<string, List<ConfigCacheEntry>>(GitConfigurationKeyComparer.Instance);
 
-                var origin = new StringBuilder();
+                var scope = new StringBuilder();
                 var key = new StringBuilder();
                 var value = new StringBuilder();
 
                 int i = 0;
                 while (i < data.Length)
                 {
-                    origin.Clear();
+                    scope.Clear();
                     key.Clear();
                     value.Clear();
 
-                    // Read origin (NUL terminated)
+                    // Read scope (NUL terminated)
                     while (i < data.Length && data[i] != '\0')
                     {
-                        origin.Append(data[i++]);
+                        scope.Append(data[i++]);
                     }
 
                     if (i >= data.Length)
                     {
-                        trace.WriteLine("Invalid Git configuration output. Expected null terminator (\\0) after origin.");
+                        trace.WriteLine("Invalid Git configuration output. Expected null terminator (\\0) after scope.");
                         break;
                     }
 
@@ -225,7 +212,7 @@ public void Load(string data, ITrace trace)
                     i++;
 
                     string keyStr = key.ToString();
-                    var entry = new ConfigCacheEntry(origin.ToString(), value.ToString());
+                    var entry = new ConfigCacheEntry(scope.ToString(), value.ToString());
 
                     if (!entries.ContainsKey(keyStr))
                     {
@@ -398,7 +385,7 @@ private void EnsureCacheLoaded(GitConfigurationType type)
                 return;
             }
 
-            using (ChildProcess git = _git.CreateProcess($"config list --show-origin -z {typeArg}"))
+            using (ChildProcess git = _git.CreateProcess($"config list --show-scope -z {typeArg}"))
             {
                 git.Start(Trace2ProcessClass.Git);
                 // To avoid deadlocks, always read the output stream first and then wait