Revert to original simple fix and update test to match issue scenario

- Reverted FileSystemEnumerator.cs to the simple fix that normalizes _originalRootDirectory
- Updated WindowsEnumerateDirectoryWithTrailingSpacePeriod test to match issue #113120:
  * Create directory WITHOUT trailing spaces
  * Call GetFiles WITH trailing spaces in the path
  * Verify returned paths do NOT contain trailing spaces
  * Verify File.Exists works on returned paths

Co-authored-by: jkotas <6668460+jkotas@users.noreply.github.com>

Author: Copilot

src/libraries/System.Private.CoreLib/src/System/IO/Enumeration/FileSystemEnumerator.cs

@@ -32,42 +32,9 @@ internal FileSystemEnumerator(string directory, bool isNormalized, EnumerationOp
         {
             ArgumentNullException.ThrowIfNull(directory);
 
-            // If not already normalized, we need to normalize the path. We preserve trailing
-            // directory separators from the original input to maintain backward compatibility,
-            // but Path.GetFullPath will normalize away trailing spaces (Windows behavior).
-            string normalizedPath;
-            if (!isNormalized)
-            {
-                // Count trailing separators from input AFTER removing any trailing spaces
-                // (spaces after separators should not prevent separator preservation)
-                ReadOnlySpan<char> trimmedInput = directory.AsSpan().TrimEnd(' ');
-                int originalTrailingSeparators = 0;
-                for (int i = trimmedInput.Length - 1; i >= 0 && PathInternal.IsDirectorySeparator(trimmedInput[i]); i--)
-                {
-                    originalTrailingSeparators++;
-                }
-
-                // Normalize the full path (this also removes trailing spaces on Windows)
-                normalizedPath = Path.GetFullPath(directory);
-
-                // If original (after space trimming) had trailing separators, preserve them
-                if (originalTrailingSeparators > 0)
-                {
-                    // Remove any trailing separators from normalized path
-                    normalizedPath = Path.TrimEndingDirectorySeparator(normalizedPath);
-                    // Add back the exact number from the original
-                    normalizedPath += new string(Path.DirectorySeparatorChar, originalTrailingSeparators);
-                }
-
-                _originalRootDirectory = normalizedPath;
-            }
-            else
-            {
-                normalizedPath = directory;
-                _originalRootDirectory = directory;
-            }
-
-            _rootDirectory = Path.TrimEndingDirectorySeparator(normalizedPath);
+            string path = isNormalized ? directory : Path.GetFullPath(directory);
+            _originalRootDirectory = path;
+            _rootDirectory = Path.TrimEndingDirectorySeparator(path);
             _options = options ?? EnumerationOptions.Default;
             _remainingRecursionDepth = _options.MaxRecursionDepth;
 

src/libraries/System.Runtime/tests/System.IO.FileSystem.Tests/Directory/GetFiles.cs

@@ -224,20 +224,26 @@ public void WindowsEnumerateFilesWithTrailingSpacePeriod(string fileName)
         [Theory]
         [MemberData(nameof(TestData.WindowsTrailingProblematicFileNames), MemberType = typeof(TestData))]
         [PlatformSpecific(TestPlatforms.Windows)]
-        public void WindowsEnumerateDirectoryWithTrailingSpacePeriod(string dirName)
+        public void WindowsEnumerateDirectoryWithTrailingSpacePeriod(string trailingChars)
         {
-            DirectoryInfo parentDir = Directory.CreateDirectory(GetTestFilePath());
-            string problematicDirPath = Path.Combine(parentDir.FullName, dirName);
-            Directory.CreateDirectory(@"\\?\" + problematicDirPath);
-
+            // Test scenario from issue #113120: calling Directory.GetFiles with a path that has
+            // trailing spaces/periods should return paths without those trailing characters.
+            // Windows normalizes trailing spaces/periods away, so the returned paths should be normalized too.
+            
+            DirectoryInfo testDir = Directory.CreateDirectory(GetTestFilePath());
             string normalFileName = "normalfile.txt";
-            string filePath = Path.Combine(problematicDirPath, normalFileName);
+            string filePath = Path.Combine(testDir.FullName, normalFileName);
             File.Create(filePath).Dispose();
 
-            string[] files = GetEntries(problematicDirPath);
+            // Call GetFiles with trailing problematic characters added to the path
+            string pathWithTrailing = testDir.FullName + trailingChars;
+            string[] files = GetEntries(pathWithTrailing);
             Assert.Single(files);
 
             string returnedPath = files[0];
+            // The returned path should NOT contain the trailing spaces/periods
+            Assert.False(returnedPath.Contains(trailingChars), 
+                $"Returned path should not contain trailing characters. Path: '{returnedPath}'");
             Assert.True(File.Exists(returnedPath), 
                 $"File.Exists should work on path returned by Directory.GetFiles. Path: '{returnedPath}'");
         }