review: harden IsInstalled() with assembly version checks

Address PR review: file-existence alone treats a stale v4 of
System.Runtime.CompilerServices.Unsafe (or any other downgraded plugin) as
"installed" and silently masks the bootstrap failure this PR is meant to fix.

Read each on-disk DLL's manifest via AssemblyName.GetAssemblyName(...).Version
and compare to the NuGet entry's declared version; if the file is older than
declared or its manifest can't be read, return false so Install() rewrites it.
Applied uniformly to all entries (defense-in-depth, per the optional suggestion
in the review).

Notes:
- System.Version comparison handles "6.0.0" (Revision=-1) vs "6.0.0.0"
  (Revision=0) correctly: the higher-revision actual passes; a stale v4 fails.
- AssemblyName.GetAssemblyName only reads the manifest, no assembly load into
  the AppDomain, so this is cheap and side-effect-free.
- Validated locally: with the v6 DLL in Plugins/Roslyn/, IsInstalled returns
  true; manually swapping in a v4 placeholder causes it to return false and
  Install() proceeds.

Author: sMartz1

MCPForUnity/Editor/Setup/RoslynInstaller.cs

@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using System.IO.Compression;
+using System.Reflection;
 using UnityEditor;
 using UnityEngine;
 using UnityEngine.Networking;
@@ -28,8 +29,29 @@ public static bool IsInstalled()
             string folder = Path.Combine(Application.dataPath, PluginsRelPath);
             foreach (var entry in NuGetEntries)
             {
-                if (!File.Exists(Path.Combine(folder, entry.dllName)))
+                string path = Path.Combine(folder, entry.dllName);
+                if (!File.Exists(path))
                     return false;
+
+                // Defense-in-depth: a stale DLL whose assembly version is older than what
+                // Roslyn references (e.g. a v4.x System.Runtime.CompilerServices.Unsafe
+                // shadowing the v6 we actually need) would still satisfy file-existence but
+                // leave Roslyn unable to load. Compare the on-disk assembly version against
+                // each entry's declared NuGet version, treating "older or unreadable" as not
+                // installed so Install() can rewrite it.
+                if (Version.TryParse(entry.version, out var requiredVersion))
+                {
+                    try
+                    {
+                        var actual = AssemblyName.GetAssemblyName(path).Version;
+                        if (actual == null || actual < requiredVersion)
+                            return false;
+                    }
+                    catch
+                    {
+                        return false;
+                    }
+                }
             }
             return true;
         }