refactor(sf,site): both stores take ILocalDb instead of a connection string

Tasks 5 and 6 of the Phase 2 plan, committed together because their test
fallout is entangled — several fixtures construct both stores.

StoreAndForwardStorage and SiteStorageService now take ILocalDb. Connections
come from ILocalDb.CreateConnection(), which hands out an already-open,
pragma-configured connection carrying the zb_hlc_next() UDF the capture triggers
call; a raw connection would lack the UDF and every write to a replicated table
would fail closed. Deleted with the connection strings: S&F's
EnsureDatabaseDirectoryExists and its per-open busy_timeout pragma, and the site
service's BusyTimeoutFloorSeconds normalization — LocalDb owns all of it now.

DI: AddSiteRuntime's string overload is gone (nothing left to supply), so the
Host calls the no-arg form. ScadaBridge:Database:SiteDbPath and
StoreAndForwardOptions.SqliteDbPath survive only as the migrator's source
locations in Tasks 8/9.

Two things the plan did not anticipate, both worth reading:

1. FOUND A REAL LATENT DEFECT, from Phase 1, now fixed. The plan assumed
   directory creation simply moved to LocalDb along with file ownership. It did
   not: the LocalDb library never creates the parent directory, and
   SqliteLocalDb opens the file eagerly in its constructor — so a missing
   directory is a hard boot failure ("SQLite Error 14: unable to open database
   file"), not a degraded start. The default site config points at the RELATIVE
   path ./data/site-localdb.db, so any site node without a pre-existing data/
   directory fails to boot. The docker rig escapes only because its volume mount
   happens to create /app/data — a coincidence that would have hidden this until
   a bare-metal or fresh deployment. This has been latent since Phase 1 made
   LocalDb:Path required; deleting S&F's EnsureDatabaseDirectoryExists here
   would have widened it. Re-established the guarantee at the layer that now
   owns the path (SiteLocalDbDirectory.Ensure, called before AddZbLocalDb) and
   pinned it with SiteLocalDbDirectoryTests. Non-vacuity is not assumed: two
   tests written against the wrong assumption failed with exactly this
   SQLite Error 14 before the fix existed.

2. Test fallout was ~7x the plan's estimate. The plan named "fixtures" in one
   project; the constructor change actually reaches 40 files across 7 test
   projects, and most used Mode=Memory;Cache=Shared — which LocalDb has no
   equivalent for, so every one had to move to a real temp file. Rather than
   copy the Phase 1 TestLocalDb fixture into 7 projects, added a shared
   tests/ZB.MOM.WW.ScadaBridge.TestSupport library (not a test project) so the
   WAL-sidecar cleanup and the "real, not stubbed" rationale live in one place.

Retargeted rather than deleted, in both directions: the S&F WAL test now asserts
against the LocalDb-backed store (WAL genuinely is LocalDb's job), while the
directory-creation test moved to Host.Tests (that guarantee is NOT LocalDb's).
SiteStorageServiceTests.Initialize_EnablesWalJournalMode got the same treatment.
DeploymentManagerMediumFindingsTests induced a persistence failure via an
unopenable path, which no longer reaches the assertion since the fixture now
throws first; it induces the same failure shape via an uninitialized store.

Verified: full solution build 0 warnings; SiteRuntime 532, Host 318,
AuditLog 355, ExternalSystemGateway 142, HealthMonitoring 97,
StoreAndForward 153 — 1597 passed, 0 failed.

Claude-Session: https://claude.ai/code/session_01BL2Vu1ESDQ9SCN4gVKkdts

tests/ZB.MOM.WW.ScadaBridge.TestSupport/TestLocalDb.cs

@@ -0,0 +1,91 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using ZB.MOM.WW.LocalDb;
+
+namespace ZB.MOM.WW.ScadaBridge.TestSupport;
+
+/// <summary>
+/// A real <see cref="ILocalDb"/> over a temp file, for tests that construct a
+/// LocalDb-backed store directly.
+/// </summary>
+/// <remarks>
+/// <para>
+/// The stores take <see cref="ILocalDb"/> rather than a connection string, and there is
+/// no in-memory mode — <c>LocalDbOptions.Path</c> is a filesystem path. A real one is
+/// used rather than a stub on purpose: connections handed out by <c>ILocalDb</c> carry
+/// the <c>zb_hlc_next()</c> UDF that the capture triggers call, so a stub returning a
+/// bare <c>SqliteConnection</c> would pass these tests while failing closed the moment
+/// the table is registered for replication.
+/// </para>
+/// <para>
+/// No <c>onReady</c> callback and no <c>RegisterReplicated</c>: each store's own schema
+/// initialization creates its table, which is what keeps a directly-constructed store
+/// self-sufficient. Registration is the host's job (<c>SiteLocalDbSetup.OnReady</c>).
+/// </para>
+/// <para>
+/// This lives in a shared support project rather than being copied per test project:
+/// seven test projects construct stores that now take <see cref="ILocalDb"/>, and
+/// duplicating the fixture would mean seven places to keep the WAL-sidecar cleanup and
+/// the "real, not stubbed" rationale correct.
+/// </para>
+/// </remarks>
+public sealed class TestLocalDb : IDisposable
+{
+    private readonly ServiceProvider _provider;
+
+    private TestLocalDb(ServiceProvider provider, ILocalDb db)
+    {
+        _provider = provider;
+        Db = db;
+    }
+
+    /// <summary>The live local database.</summary>
+    public ILocalDb Db { get; }
+
+    /// <summary>Opens a local database at <paramref name="databasePath"/>.</summary>
+    public static TestLocalDb Create(string databasePath)
+    {
+        var configuration = new ConfigurationBuilder()
+            .AddInMemoryCollection(new Dictionary<string, string?>
+            {
+                ["LocalDb:Path"] = databasePath,
+            })
+            .Build();
+
+        var provider = new ServiceCollection()
+            .AddZbLocalDb(configuration)
+            .BuildServiceProvider();
+
+        return new TestLocalDb(provider, provider.GetRequiredService<ILocalDb>());
+    }
+
+    /// <summary>
+    /// Creates a local database at a fresh temp path. Dispose the instance, then call
+    /// <see cref="DeleteFiles"/> with <see cref="Path"/> to clean up.
+    /// </summary>
+    public static TestLocalDb CreateTemp(string prefix = "localdb")
+    {
+        var path = System.IO.Path.Combine(
+            System.IO.Path.GetTempPath(), $"{prefix}-{Guid.NewGuid():N}.db");
+        var db = Create(path);
+        db.Path = path;
+        return db;
+    }
+
+    /// <summary>The filesystem path, when created via <see cref="CreateTemp"/>.</summary>
+    public string Path { get; private set; } = string.Empty;
+
+    /// <summary>
+    /// Deletes <paramref name="databasePath"/> and its WAL sidecars. Call only after the
+    /// owning <see cref="TestLocalDb"/> is disposed — the master connection anchors the WAL.
+    /// </summary>
+    public static void DeleteFiles(string databasePath)
+    {
+        foreach (var suffix in new[] { "", "-wal", "-shm" })
+        {
+            try { File.Delete(databasePath + suffix); } catch { /* best effort */ }
+        }
+    }
+
+    public void Dispose() => _provider.Dispose();
+}