test(siteruntime): close register row 91 — compile-cache asserts become key-scoped deltas

SiteScriptCompileCacheTests.GetOrAdd_SameCodeAndGlobals_ComputesOnce asserted
Assert.Equal(1, SiteScriptCompileCache.Hits) after a Clear() on what is a
process-wide static cache. The [Collection("SiteScriptCompileCache")] attribute
serializes this class against ScriptCompilationServiceTests and
DeploymentWarmThenGateTests, but NOT against the rest of the assembly: every
class that compiles a script — Instance/Script actor tests, deployment tests —
goes through the same GetOrAdd in parallel and bumps the same global Hits/Count.
Failed ~1 run in 4 under a full parallel solution run, green in isolation.

Fixed with the register's row-74 pattern (98c94588): assert the DELTA
attributable to this test's OWN keys, never an absolute global value. Two habits
carry it.

1. Every test now keys its entries on a per-test-instance guid token (the new
   Code() helper embeds it as a comment), so no other class in the assembly can
   collide with or serve them. That makes the factory-call counts and
   Assert.Same identity checks exact and fully owned — and those are the real
   claims: "computed once" and "the second lookup returned that instance".
2. The process-global counters are only ever asserted as one-sided bounds
   (>= baseline + n), since foreign traffic can only add. There is no concurrent
   Clear() to make a delta go negative: all three classes that call Clear() are
   in the serialized collection.

Four assertions changed shape, and two got stronger rather than weaker.
GetOrAdd_SameCode_DifferentGlobals_AreSeparateEntries asserted Count == 2 and
Hits == 0 — both only true while nothing else was compiling. "No cross-globals
hit" is now asserted where it is observable and ours: the second lookup HAD to
compute, the two results are not the same instance, and re-getting either serves
its own entry rather than the other globals surface's. Overflow_StaysWithinTheBound
gained an eviction probe over its own keys — a bound with foreign slack is not
proof a sweep ran; a recompute of an entry we inserted is.
Overflow_EvictsOldestBatch_… had Assert.Equal(hitsBefore + 1, Hits), the same
absolute-delta shape, now a lower bound alongside the sharp Assert.Same.

DeploymentWarmThenGateTests carried the identical latent shape one line before
its own delta assertion — Assert.Equal(0, Hits) immediately after Clear() —
and is converted to a baseline snapshot too.

SiteRuntime.Tests: 633/633 green, twice, at full parallelism (43 s, 42 s).

tests/ZB.MOM.WW.ScadaBridge.SiteRuntime.Tests/Actors/DeploymentWarmThenGateTests.cs

@@ -248,15 +248,20 @@ public class DeploymentWarmThenGateTests : TestKit, IDisposable
             "BatchTwo", ConfigJson("BatchTwo", sharedCode), "d2", "h2", true);
 
         SiteScriptCompileCache.Clear();
-        Assert.Equal(0, SiteScriptCompileCache.Hits);
+        // Baseline rather than Assert.Equal(0, Hits): Hits is a process-global counter and test
+        // classes outside this collection compile scripts in parallel, so a foreign hit can land
+        // between the Clear() and the read (deferred-work register row 91). Everything below is
+        // asserted as a delta over this baseline.
+        var hitsBefore = SiteScriptCompileCache.Hits;
 
         CreateDeploymentManager();
 
         AwaitAssert(() =>
         {
             // One compile, then repeated hits: the second pre-warm plus both PreStarts.
-            Assert.True(SiteScriptCompileCache.Hits >= 3,
-                $"expected the pre-warmed body to be served from cache, saw {SiteScriptCompileCache.Hits} hits");
+            Assert.True(SiteScriptCompileCache.Hits - hitsBefore >= 3,
+                $"expected the pre-warmed body to be served from cache, saw " +
+                $"{SiteScriptCompileCache.Hits - hitsBefore} hits over baseline {hitsBefore}");
         }, TimeSpan.FromSeconds(20));
     }
 }