fix: Fixes pathfinding prebake and pathfinding multi-fallthrough. (#2478)

## Summary

Fixes the pathfinding step-cache (`.swb`) prebake so it bakes **once** and skips when a valid cache already exists, instead of re-baking on every boot. The root cause was the staleness fingerprint hashing mutable in-memory tile data rather than the on-disk files. This PR makes the fingerprint a pure function of the client data files and separates dynamic multis (houses/boats) from the static cache.

> This branch builds on the `ConfigurePrompts` first-boot-prompt unification (commit `5df8d0bd`, also included here) — that commit accounts for the `ServerConfiguration.cs` and `dev-docs/server-lifecycle.md` changes in the diff.

## The bug

With `pathfinding.prebakeMaps` set, the cache re-baked on **every** boot. The `.swb` staleness fingerprint hashed the live `TileData.LandTable`/`ItemTable` flags, which the server patches at runtime (`ItemFixes`, `LOSBlocker`, `PotionKeg`, `CTF`) at nondeterministic lifecycle points (Initialize-phase methods share a priority; static ctors fire lazily). So a fingerprint stamped at runtime (`[PathBake`) never matched the one recomputed during startup `Initialize()`, and the cache rebaked every time.

## Changes

**1. Fingerprint the files, not the in-memory tables** (`fix`)
Hash `tiledata.mul` (cached, computed once) plus the per-map `.mul`/`.uop` files — never the runtime-mutated `TileData` tables. The fingerprint is now lifecycle-stable. Existing `.swb` files rebake once after deploy, then stay stable.

**2. Compute the fingerprint once per boot** (`refactor`)
`Configure()`'s `AutoLoadAtStartup()` already opens and fingerprint-validates a reader for every up-to-date `.swb`. `Initialize()` now skips baking any map that already has an open reader (`StepCache.HasLazyReader`) instead of recomputing the fingerprint a second time.

**3. Bake static-only; route multis to the live path** (`refactor`)
Multis (houses/boats) are dynamic, so they're no longer baked into the static chunk cache — they were tagged with `BuiltMultisVersion`, a non-persisted session counter, which made persisting them unsafe (false matches / wasted re-bakes).
- Chunks bake land + `statics.mul` only.
- At query time, any cell whose sector (or its 1-cell halo) contains a multi routes to `Fallthrough_Multi` → the existing live, multi-aware `CheckMovement` path. The halo prevents a cell proposing a walkable edge into a neighbouring wall; interior (multi-free) cells pay one sector lookup.
- Adds `Sector.HasMultis` (one engine accessor); `.swb` format → v9 (rejects old multi-baked files); new `Fallthrough_Multi` telemetry.
- Behaviour-preserving: multis use the same live path the engine used before the cache existed.

**4. Comment polish** (`style`) — no behaviour change.

## Testing

All green: **92** pathfinding (incl. a new fingerprint-stability test and a multi-halo fallthrough test), **423** UOContent, **708** Server.

## Follow-ups (not in this PR)

- **Background bake worker** — make `[PathBake` and the boot prebake non-blocking (game thread serves tile reads to an off-thread worker).
- **Per-multi MCL cache** — cache walkability in each multi's own frame (keyed by multiID, movement-invariant) so houses/boats get a fast path instead of the live fallback.
- **House-pathfinding equivalence tests** — the one area not yet covered by a dedicated automated test; multi pathing is currently correct by delegation to the live path.

Projects/UOContent/Engines/Pathing/PathCacheCommands.cs

@@ -83,9 +83,14 @@ public static class PathCacheCommands
     /// <summary>
     /// Auto-invoked by <c>AssemblyHandler.Invoke("Initialize")</c> after the tile matrix and
     /// world are loaded. When <see cref="PrebakeSetting"/> is set, bakes any map whose
-    /// <c>.swb</c> is missing or stale (its tile-data fingerprint no longer matches), so the
-    /// first pathfind on each region is already warm. A fresh cache makes this a no-op, so only
-    /// first boot — or a client/map update that changes the fingerprint — pays the cost.
+    /// <c>.swb</c> is missing or stale, so the first pathfind on each region is already warm. A
+    /// fresh cache makes this a no-op, so only first boot — or a client/map update that changes
+    /// the fingerprint — pays the cost.
+    ///
+    /// Validity is decided by <see cref="StepCache.HasLazyReader"/>: <see cref="Configure"/> runs
+    /// <see cref="AutoLoadAtStartup"/> in the earlier Configure phase, opening (and fingerprint-
+    /// validating) a reader for every up-to-date <c>.swb</c>. So a map with an open reader is
+    /// already good and we skip it — no need to recompute the fingerprint a second time here.
     /// </summary>
     public static void Initialize()
     {
@@ -103,13 +108,13 @@ public static class PathCacheCommands
                 continue;
             }
 
-            var path = PathFor(map.MapID);
-            var live = StepCache.ComputeLiveFingerprint(map.MapID);
-            if (StepCache.TryReadFingerprintFromFile(path, out var onDisk) && onDisk == live)
+            if (StepCache.Instance.HasLazyReader(map.MapID))
             {
-                continue; // .swb already matches the current tile data
+                continue; // AutoLoadAtStartup already opened a fingerprint-valid .swb for this map
             }
 
+            var path = PathFor(map.MapID);
+
             logger.Information(
                 "PathBake: pre-baking map {MapId} (pathfinding.prebakeMaps) — this can take several minutes...",
                 map.MapID
@@ -156,6 +161,7 @@ public static class PathCacheCommands
         from.SendMessage($"  builds={stats.BuildsTotal} hits={stats.Hits}");
         from.SendMessage($"  miss(notBuilt)={stats.MissesNotBuilt} miss(dirty)={stats.MissesDirtyRebuild}");
         from.SendMessage($"  fallthru(multiZ)={stats.FallthroughMultiZ} fallthru(offMap)={stats.FallthroughOffMap} fallthru(srcZ)={stats.FallthroughSourceZMismatch}");
+        from.SendMessage($"  fallthru(multi)={stats.FallthroughMulti} fallthru(notBuilt)={stats.FallthroughNotBuilt}");
         from.SendMessage($"  evictions(lruCap)={stats.EvictionsByLruCap}");
     }