refactor(siteruntime): scope SiteScriptCompileCache to the ScriptCompilationService singleton — close register row 100

The compile cache was a `static` class, so its entry table and its Hits/Count
counters were one process-global blob every test class in the SiteRuntime
assembly wrote into. Row 91 last wave neutered the resulting flakes (per-test
GUID keys + one-sided counter bounds), but the shared mutable state itself
remained: any test calling Clear() evicted entries other parallel classes had
just inserted, and a Clear() from a class outside the serialized collection
would degrade the others to recompiles and re-open the row-91 flake class.

PREMISE CORRECTION: the register speculated production clears "per-instance or
per-deployment script entries" and offered ClearKeys(prefix) as the natural fit.
There are NO production callers of Clear() at all — grep of src/ finds only
GetOrAdd (ScriptCompilationService.CompileCore). Clear() existed solely so
tests could reset the global. A key-scoped API would therefore have been new
production surface built for nobody, so the instance-scoped seam is the fix and
Clear() is deleted outright rather than migrated.

- SiteScriptCompileCache: `internal static class` -> `internal sealed class`;
  Cache/EvictionLock/_hits/_accessSequence become instance fields. LRU batch
  eviction, the double-checked sweep and the ConcurrentDictionary.ToArray()
  snapshot are byte-for-byte the same policy. Clear() removed.
- ScriptCompilationService owns one cache. Public ctor (the DI path) builds its
  own; a new internal ctor takes one for tests. Production N4 sharing is
  unchanged and now rests on the DI SINGLETON registration — the one service
  instance is threaded to DeployCompileValidator and to every Instance Actor —
  so that lifetime is load-bearing and is pinned by a new registration test.
- Tests: all three Clear() callers migrated off it. Each test now owns its cache,
  which lets the assertions get STRONGER — the row-91 workarounds are retired:
  Hits/Count are exact again (no >= baseline bounds), the per-test GUID key
  token is gone, and ForeignEntrySlack (512 entries of allowance on the bound)
  drops to the racing-thread count in the concurrency test. New test
  SeparateCaches_DoNotShareEntriesOrCounters pins the scoping directly: filling
  one cache past MaxEntries leaves another's entry, hit count and identity
  intact. DeploymentWarmThenGateTests additionally asserts Count == 1 now that
  its counter is private.
- The [Collection("SiteScriptCompileCache")] serialization from row 91 is
  RELAXED (removed from all three classes) — they no longer touch any shared
  state, so there is nothing left to serialize.
- Docs: Component-SiteRuntime.md gains the ownership/singleton note and drops
  the Clear() reference; DeploymentManagerActor / DeployCompileValidator /
  ServiceCollectionExtensions comments corrected to say where the cache lives.

Build: 0 warnings. SiteRuntime.Tests 643/643, three consecutive full-parallel
runs. AuditLog.Tests correlation classes (other ScriptCompilationService
consumers) green.

src/ZB.MOM.WW.ScadaBridge.SiteRuntime/Actors/DeploymentManagerActor.cs

@@ -677,7 +677,8 @@ public class DeploymentManagerActor : ReceiveActor, IWithTimers
                 {
                     // Verdict discarded: startup does not gate on compile failures (a failing
                     // script is logged by the Instance Actor and leaves the rest running).
-                    // This call exists only to populate SiteScriptCompileCache.
+                    // This call exists only to populate the compile cache owned by the
+                    // shared ScriptCompilationService (SiteScriptCompileCache).
                     validator.Validate(configJson);
                 }
                 catch
@@ -798,8 +799,8 @@ public class DeploymentManagerActor : ReceiveActor, IWithTimers
     }
 
     /// <summary>
-    /// Compiles the deployment's scripts off the actor thread purely to populate the
-    /// process-wide <see cref="SiteScriptCompileCache"/>, then pipes
+    /// Compiles the deployment's scripts off the actor thread purely to populate the compile
+    /// cache owned by the shared <c>ScriptCompilationService</c> singleton, then pipes
     /// <see cref="DeployCompileWarmed"/> back so the authoritative gate can run on the actor
     /// thread against a warm cache. The warm is best-effort: its verdict is discarded and any
     /// exception swallowed, because <see cref="RunDeployGateAndProceed"/> re-derives the
@@ -910,9 +911,10 @@ public class DeploymentManagerActor : ReceiveActor, IWithTimers
         // already been warmed off-thread (StartDeployCompileWarm), so this call is
         // pure cache hits and no longer holds the singleton — while the per-instance
         // warm guard keeps this instance's own command ordering intact. Redeploys and
-        // multi-instance deploys of unchanged scripts hit the process-wide compile
-        // cache (SiteScriptCompileCache) too, and the Instance Actor's PreStart reuses
-        // the gate's compile (N4).
+        // multi-instance deploys of unchanged scripts hit the compile cache
+        // (SiteScriptCompileCache, owned by the ScriptCompilationService singleton this
+        // actor shares with every Instance Actor) too, and the Instance Actor's PreStart
+        // reuses the gate's compile (N4).
         var errors = _deployCompileValidator.Validate(command.FlattenedConfigurationJson);
         if (errors.Count > 0)
         {