Fix architecture detection by using .NET runtime architecture instead of system architecture (#544)

## Problem Analysis

The previous fix (#543) attempted to solve architecture detection issues
by using system architecture, but **root cause analysis** reveals the
real problem:

**Confirmed user system:**
- Hardware: ARM64 Mac (M1/M2) - `uname -m` returns `arm64`
- .NET Binary: x86_64 - `lipo -archs /usr/local/bin/dotnet` returns
`x86_64`
- .NET Runtime: `RID: osx-x64` - running under Rosetta translation
- Error: `have 'arm64', need 'x86_64'`

**What was happening:**
1. Extension detected ARM64 system → downloaded ARM64 Dafny binaries
2. .NET runtime was x64 (Rosetta) → tried to load ARM64 libraries
3. Architecture mismatch → `incompatible architecture` error

## Root Cause

The issue isn't system architecture detection - it's that **.NET can run
under Rosetta translation** on ARM64 Macs. When this happens:
- System architecture: ARM64
- .NET runtime architecture: x64
- **We need x64 Dafny binaries, not ARM64**

## Solution

**Detect .NET runtime architecture instead of system architecture:**

1. **Use `dotnet --info`** to get actual .NET runtime information
2. **Parse RID (Runtime Identifier):** `osx-x64` vs `osx-arm64`
3. **Parse Architecture field:** `x64` vs `Arm64`
4. **Download matching Dafny binaries** for the .NET runtime
architecture
5. **Fallback chain:** .NET detection → system detection → `os.arch()`

## Why This Fixes The Issue

- **ARM64 Mac + Native .NET:** Downloads ARM64 Dafny ✅
- **ARM64 Mac + Rosetta .NET:** Downloads x64 Dafny ✅  
- **x64 Mac:** Downloads x64 Dafny ✅
- **Other platforms:** Unchanged behavior ✅

This addresses the actual compatibility requirement: **Dafny binaries
must match .NET runtime architecture, not system hardware
architecture.**

## Confirmed Fix

With the user's confirmed data (`RID: osx-x64`), this fix will:
1. Parse `osx-x64` from `dotnet --info` output
2. Extract `x64` architecture
3. Download `dafny-4.11.0-x64-macos-13.zip` instead of
`dafny-4.11.0-arm64-macos-13.zip`
4. Resolve the architecture mismatch error

## Testing

The fix includes comprehensive logging to help debug architecture
detection issues and verify the correct architecture is being selected.

Supersedes #543 with the correct approach based on root cause analysis.

Author: MikaelMayer

src/language/githubReleaseInstaller.ts

@@ -126,28 +126,53 @@ export class GitHubReleaseInstaller {
     const baseUri = LanguageServerConstants.DownloadBaseUri;
     const [ tag, version ] = await this.getConfiguredTagAndVersion();
     const suffix = getDafnyPlatformSuffix(version);
-    const arch = await this.getSystemArchitecture();
+    const arch = await this.getDotnetArchitecture();
     return `${baseUri}/${tag}/dafny-${version}-${arch}-${suffix}.zip`;
   }
 
-  private async getSystemArchitecture(): Promise<string> {
+  private async getDotnetArchitecture(): Promise<string> {
     if(os.type() === 'Darwin') {
-      // On macOS, use system command to get actual hardware architecture
-      // to avoid issues with VS Code running under Rosetta
+      // On macOS, detect .NET runtime architecture to handle Rosetta translation
+      // This is crucial because ARM64 Macs may run .NET in x64 mode via Rosetta
       try {
         const { exec } = await import('child_process');
         const { promisify } = await import('util');
         const execAsync = promisify(exec);
-        const { stdout } = await execAsync('uname -m');
-        const systemArch = stdout.trim();
+
+        // First try to get .NET runtime architecture
+        const { stdout } = await execAsync('dotnet --info');
+
+        // Look for RID (Runtime Identifier) which shows the actual .NET runtime architecture
+        const ridRegex = /RID:\s*osx-(x64|arm64)/;
+        const ridMatch = ridRegex.exec(stdout);
+        if(ridMatch) {
+          this.writeStatus(`Detected .NET RID: osx-${ridMatch[1]}`);
+          return ridMatch[1]; // Returns 'x64' or 'arm64'
+        }
+
+        // Fallback: look for Architecture field
+        const archRegex = /Architecture:\s*(x64|Arm64)/i;
+        const archMatch = archRegex.exec(stdout);
+        if(archMatch) {
+          const detectedArch = archMatch[1].toLowerCase() === 'arm64' ? 'arm64' : 'x64';
+          this.writeStatus(`Detected .NET Architecture: ${detectedArch}`);
+          return detectedArch;
+        }
+
+        this.writeStatus('Could not parse .NET architecture from dotnet --info output');
+        this.writeStatus('Falling back to system architecture detection');
+
+        // Fallback to system architecture detection using same execAsync
+        const { stdout: systemStdout } = await execAsync('uname -m');
+        const systemArch = systemStdout.trim();
         return systemArch === 'x86_64' ? 'x64' : systemArch === 'arm64' ? 'arm64' : 'x64';
       } catch(error: unknown) {
-        // Fallback to Node.js detection
-        this.writeStatus(`Failed to detect system architecture via uname: ${error}`);
+        this.writeStatus(`Failed to detect architecture: ${error}`);
         this.writeStatus('Falling back to Node.js process architecture detection');
         return os.arch();
       }
     }
+
     // For non-macOS systems, use Node.js detection (preserve original behavior)
     return os.arch();
   }