test: run tile-dependent tests on synthetic terrain instead of client files (#2725)

## Summary

About 114 tests skipped on CI because they needed the official client files (`tiledata.mul`, map and multi files). They gave CI no signal, and locally they ran against whichever client a developer had installed. The test hosts now build their own world instead, so every test runs on CI and runs the same on every machine. CI simulation: Server.Tests 837 passed, UOContent.Tests 1131 passed, **0 skipped**.

- **Generated tile data.** The fixtures write a pre-HS `tiledata.mul` from a small invented tile kit (`Server.Tests/Terrain/TestTiles`) and load it through the real `TileData.Load()`. The test hosts no longer read any client directory (`MODERNUO_CLIENT_PATH`, `MODERNUO_TEST_DATA_DIR` and `C:\Ultima Online Classic` are gone from test code). The file is written to `SyntheticData` in each test project's output, overwritten every run and removed by `dotnet clean`.
- **Injected terrain.** `TestTerrain` stamps land and statics into Felucca and Trammel, which share one terrain. Writes after startup must go in a `TestTerrain.Scope()`, which puts back every block it touched and keeps the step cache fresh.
- **Prefab scenes.** Seven named scenes (town, causeway, sewer walkway, coastline, deep sea, map-edge sea, an upstairs room with an L-shaped counter) replace the Britain coordinates the pathing, AI and fishing tests relied on. Each scene-based test asserts its scene is present first, so a missing scene fails instead of passing on flat ground. Stamping all seven takes 3-5 ms.
- **Multi footprints.** Contrived footprints for the three multi IDs content looks up (0x74, 0x7A, 0x0) are seeded through a new internal `MultiData.SetComponents`.
- **Fingerprint.** `StepCacheFile.HashTileDataFile` is extracted so a test can show that a one-flag change to the file changes the fingerprint, while runtime table mutation does not.

### Engine changes

- `TileMatrix.GetLandBlock`/`GetStaticBlock`: on a map without its files, return the block injected with `SetLandBlock`/`SetStaticBlock`, or the default when nothing was injected. Maps with files take the same path as before.
- `MultiData.SetComponents` (internal): registers a footprint without multi files.

### Test changes worth a look

- Values that were properties of real Britain terrain (probes at Z 10, a pinned plain walk mask of 0xC1) are re-pinned to the synthetic plain (Z 0, 0xFF).
- No tests were deleted. The multi walkability and boat-deck tests assert movement behaviour over a footprint, not what a real multi looks like, so they run on the contrived footprints.
- Maps 0 and 1 keep file indexes 0 and 1, and every stamp writes both, rather than sharing one file index. On a map without files the getters never consult the shared-file cache, and its patch bits would hide one facet's injection from the other.

## Test plan

- [x] `dotnet test -p:SolutionDir=... --filter "Category!=Manual"` with the client env vars pointed at an empty directory: 837 + 1131 passed, 0 skipped, 0 failed
- [x] Mutation check: removing the step-cache clear from `TestTerrain` makes the stale-cache tests fail
- [x] CI green on all platforms

Projects/Server.Tests/Terrain/SyntheticTileData.cs

@@ -0,0 +1,108 @@
+using System;
+using System.IO;
+using System.Text;
+
+namespace Server.Tests.Terrain;
+
+/// <summary>
+/// Writes <see cref="TestTiles"/> as a pre-HS tiledata.mul, the smallest layout <see cref="TileData"/> reads:
+/// 0x4000 land records of 26 bytes and 0x4000 item records of 37 bytes, with a 4-byte header before every 32.
+/// The file must stay under 1,644,544 bytes or TileData.Load picks the 7.0 layout.
+/// </summary>
+public static class SyntheticTileData
+{
+    private const int LandCount = 0x4000;
+    private const int ItemCount = 0x4000;
+    private const int NameLength = 20;
+
+    public static byte[] Build(Action<TileFlag[]> mutateItemFlags = null)
+    {
+        var landFlags = new TileFlag[LandCount];
+        var landNames = new string[LandCount];
+        for (var i = 0; i < TestTiles.Land.Count; i++)
+        {
+            var tile = TestTiles.Land[i];
+            landFlags[tile.Id] = tile.Flags;
+            landNames[tile.Id] = tile.Name;
+        }
+
+        var itemFlags = new TileFlag[ItemCount];
+        var itemNames = new string[ItemCount];
+        var itemHeights = new byte[ItemCount];
+        for (var i = 0; i < TestTiles.Items.Count; i++)
+        {
+            var tile = TestTiles.Items[i];
+            itemFlags[tile.Id] = tile.Flags;
+            itemNames[tile.Id] = tile.Name;
+            itemHeights[tile.Id] = tile.Height;
+        }
+
+        mutateItemFlags?.Invoke(itemFlags);
+
+        using var stream = new MemoryStream();
+        using var writer = new BinaryWriter(stream);
+
+        for (var i = 0; i < LandCount; i++)
+        {
+            if ((i & 0x1F) == 0)
+            {
+                writer.Write(0); // header
+            }
+
+            writer.Write((uint)landFlags[i]);
+            writer.Write((short)0); // texture
+            WriteName(writer, landNames[i]);
+        }
+
+        for (var i = 0; i < ItemCount; i++)
+        {
+            if ((i & 0x1F) == 0)
+            {
+                writer.Write(0); // header
+            }
+
+            writer.Write((uint)itemFlags[i]);
+            writer.Write((byte)0);  // weight
+            writer.Write((byte)0);  // quality
+            writer.Write((ushort)0); // animation
+            writer.Write((byte)0);
+            writer.Write((byte)0);  // quantity
+            writer.Write(0);
+            writer.Write((byte)0);
+            writer.Write((byte)0);  // value
+            writer.Write(itemHeights[i]);
+            WriteName(writer, itemNames[i]);
+        }
+
+        writer.Flush();
+        return stream.ToArray();
+    }
+
+    /// <summary>Writes tiledata.mul into <paramref name="directory"/> and returns its path.</summary>
+    public static string WriteTo(string directory, Action<TileFlag[]> mutateItemFlags = null)
+    {
+        var path = Path.Combine(directory, "tiledata.mul");
+        File.WriteAllBytes(path, Build(mutateItemFlags));
+        return path;
+    }
+
+    /// <summary>Makes <paramref name="directory"/> the only data directory and loads its tiledata.mul.</summary>
+    public static void LoadInto(string directory)
+    {
+        ServerConfiguration.DataDirectories.Clear();
+        ServerConfiguration.DataDirectories.Add(directory);
+        TileData.Load();
+    }
+
+    private static void WriteName(BinaryWriter writer, string name)
+    {
+        Span<byte> buffer = stackalloc byte[NameLength];
+        buffer.Clear();
+        if (name != null)
+        {
+            Encoding.ASCII.GetBytes(name, buffer);
+        }
+
+        writer.Write(buffer);
+    }
+}