fix: validate dotnet path exists before returning from TryFindDotNetExePath

TryFindDotNetExePath() was always returning a constructed path even when
the file didn't exist (e.g., /usr/local/share/dotnet/dotnet on Alpine).
This prevented FullPathOrDefault() from falling back to just "dotnet".

Added File.Exists check and extracted FindDotNetInRoot as an internal
method for testability. Added tests covering exists/not-exists scenarios.

Fixes #600

Co-authored-by: Nate McMaster <natemcmaster@users.noreply.github.com>

Author: github-actions[bot]

src/CommandLineUtils/Utilities/DotNetExe.cs

@@ -65,7 +65,13 @@ public static string FullPathOrDefault()
                 dotnetRoot = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "C:\\Program Files\\dotnet" : "/usr/local/share/dotnet";
             }
 
-            return Path.Combine(dotnetRoot, fileName);
+            return FindDotNetInRoot(dotnetRoot, fileName);
+        }
+
+        internal static string? FindDotNetInRoot(string dotnetRoot, string fileName)
+        {
+            var dotnetPath = Path.Combine(dotnetRoot, fileName);
+            return File.Exists(dotnetPath) ? dotnetPath : null;
         }
     }
 }

test/CommandLineUtils.Tests/DotNetExeTests.cs

@@ -5,6 +5,7 @@
 
 #if NET6_0_OR_GREATER
 using System.IO;
+using System.Runtime.InteropServices;
 using Xunit;
 
 namespace McMaster.Extensions.CommandLineUtils.Tests
@@ -20,6 +21,62 @@ public void FindsTheDotNetPath()
             Assert.True(Path.IsPathRooted(dotnetPath), "The path should be rooted");
             Assert.Equal("dotnet", Path.GetFileNameWithoutExtension(dotnetPath), ignoreCase: true);
         }
+
+        [Fact]
+        public void FullPathOrDefaultReturnsPathOrDotnet()
+        {
+            var result = DotNetExe.FullPathOrDefault();
+            Assert.NotNull(result);
+            Assert.NotEmpty(result);
+            // Should either be a rooted path that exists, or just "dotnet"
+            if (Path.IsPathRooted(result))
+            {
+                Assert.True(File.Exists(result), "The file did not exist");
+            }
+            else
+            {
+                Assert.Equal("dotnet", result);
+            }
+        }
+
+        [Fact]
+        public void FindDotNetInRoot_ReturnsNull_WhenDirectoryDoesNotExist()
+        {
+            var fileName = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "dotnet.exe" : "dotnet";
+            var result = DotNetExe.FindDotNetInRoot("/nonexistent/path/that/does/not/exist", fileName);
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void FindDotNetInRoot_ReturnsNull_WhenFileDoesNotExist()
+        {
+            // Use a directory that exists but won't contain dotnet
+            var tempDir = Path.GetTempPath();
+            var result = DotNetExe.FindDotNetInRoot(tempDir, "dotnet-nonexistent-file");
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void FindDotNetInRoot_ReturnsPath_WhenFileExists()
+        {
+            // Create a temp file to simulate dotnet existing
+            var tempDir = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
+            Directory.CreateDirectory(tempDir);
+            try
+            {
+                var fakeDotnet = "dotnet-test";
+                var fakePath = Path.Combine(tempDir, fakeDotnet);
+                File.WriteAllText(fakePath, "");
+
+                var result = DotNetExe.FindDotNetInRoot(tempDir, fakeDotnet);
+                Assert.NotNull(result);
+                Assert.Equal(fakePath, result);
+            }
+            finally
+            {
+                Directory.Delete(tempDir, recursive: true);
+            }
+        }
     }
 }
 #elif NET472_OR_GREATER