feat(pathfinding): JSONL recorder + public bake helpers (#2449)

## Summary

Adds two pieces of pathfinding tooling on top of PR #2448's lazy `.swb` infrastructure:

- **`PathfindRecorder`** — admin-toggled JSONL telemetry capture; one record per `BitmapAStarAlgorithm.Find` call. Output format matches the BDN harness corpus, so production traffic can be captured and replayed in benchmarks without an adapter.
- **Public bake helpers on `StepCache`** — `ComputeLiveTileDataHash`, `TryReadTileDataHashFromFile`, `BakeMap`, `ClearResidentChunks`. Lets the benchmark project (and any future bake utility) drive cache fill + persist without exposing internal types.

The companion BDN harness update lives in [ModernUO-Benchmarks#kb/pathfinding-pr4-bench](https://github.com/modernuo/ModernUO-Benchmarks/tree/kb/pathfinding-pr4-bench): porting `Benchmarks/PathfindInGame/` from the `kb/ai_pathfinding` branch to the API shipped in #2446–#2448.

## What's in this PR

### `PathfindRecorder` (`PathfindRecorder.cs`)
- Holds a single `StreamWriter` open while recording; its internal buffer absorbs per-record writes without per-call `File.AppendAllText`.
- Single `bool` check on the hot path; cheap when disabled.
- Disabling flushes + disposes; an IO failure during write also disables the recorder.
- Server config:
  - `pathfinding.recorder.enable` — bool, default `false`. Read on boot via `GetOrUpdateSetting`.
  - `pathfinding.recorder.path` — default `<basedir>/Data/Pathfinding/recordings/pathfinds.jsonl`.
- Hooked into `BitmapAStarAlgorithm.Find` — runs once per call, does nothing when disabled.
- Admin command: `[PathRecord [on|off|flush|status]` (default `status`).

### Public cache helpers
- `static ulong StepCache.ComputeLiveTileDataHash()` — wraps the file module's hash function for staleness checks.
- `static bool StepCache.TryReadTileDataHashFromFile(string, out ulong)` — peeks at a `.swb` file's hash field (20 bytes).
- `int StepCache.BakeMap(int, string)` — walks every chunk in the map, populates resident set, saves. Offline / fixture use; blocks for many seconds on a full-map walk.
- `void StepCache.ClearResidentChunks()` — drops chunks + zeros counters but keeps lazy readers open. Lets benchmark loops measure "first query after boot" cost across iterations without the lazy-reader reopen overhead.

Projects/UOContent/Engines/Pathing/Cache/StepCache.cs

@@ -64,10 +64,21 @@ public sealed class StepCache
     /// counters are since-last-clear, not since-startup.
     /// </summary>
     public void Clear()
+    {
+        ClearResidentChunks();
+        CloseLazyReaders();
+    }
+
+    /// <summary>
+    /// Drop all resident chunks AND zero counters, but keep lazy readers open.
+    /// Useful in benchmark loops that want to measure "first query after boot" cost
+    /// without paying the lazy-reader reopen overhead each iteration. Same intent as
+    /// <see cref="Clear"/> minus the file-handle teardown.
+    /// </summary>
+    public void ClearResidentChunks()
     {
         _chunks.Clear();
         _keysList.Clear();
-        CloseLazyReaders();
         _hits = 0;
         _missesNotBuilt = 0;
         _missesDirtyRebuild = 0;
@@ -83,6 +94,51 @@ public sealed class StepCache
     // stays bounded by MaxResidentChunks regardless of file size.
     private readonly Dictionary<int, StepCacheFile.LazyReader> _lazyReaders = new();
 
+    /// <summary>
+    /// Combined XxHash3 fingerprint of the running server's TileData flag tables AND
+    /// the per-map .mul / .uop file contents (mapX.mul, staidxX.mul, staticsX.mul).
+    /// Public surface for tooling (benchmark fixtures, bake utilities) that wants to
+    /// detect a stale .swb file without round-tripping through the lazy-open path.
+    /// </summary>
+    public static ulong ComputeLiveFingerprint(int mapId) => StepCacheFile.ComputeFingerprint(mapId);
+
+    /// <summary>
+    /// Peek at a .swb file's stored fingerprint field without parsing the rest of the
+    /// header. Returns false on missing file, bad magic, or wrong version.
+    /// </summary>
+    public static bool TryReadFingerprintFromFile(string path, out ulong fingerprint) =>
+        StepCacheFile.TryReadFingerprint(path, out fingerprint);
+
+    /// <summary>
+    /// Walk every chunk in <paramref name="mapId"/>, populate the resident set, then
+    /// save to <paramref name="path"/>. Returns the number of chunks written.
+    /// Designed for offline / fixture use; blocks the calling thread for many seconds
+    /// on a full Trammel walk.
+    /// </summary>
+    public int BakeMap(int mapId, string path)
+    {
+        var map = Map.Maps[mapId];
+        if (map == null || map == Map.Internal)
+        {
+            return 0;
+        }
+
+        var chunkCols = (map.Width + ChunkSize - 1) / ChunkSize;
+        var chunkRows = (map.Height + ChunkSize - 1) / ChunkSize;
+
+        for (var cy = 0; cy < chunkRows; cy++)
+        {
+            for (var cx = 0; cx < chunkCols; cx++)
+            {
+                // Any sourceZ works — the chunk is built on first access regardless of
+                // whether the query returns Hit or Fallthrough_SourceZMismatch.
+                TryGetMask(map, cx * ChunkSize, cy * ChunkSize, sourceZ: 0);
+            }
+        }
+
+        return SaveToFile(path, mapId);
+    }
+
     /// <summary>
     /// Persist all resident chunks for <paramref name="mapId"/> to a .swb file. Returns
     /// the number of chunks written. The file embeds a TileData fingerprint so a stale