test(pipeline): MP1b - live-vs-pak equivalence suite (dat-gated)

PakEquivalenceTests runs MeshExtractor LIVE and bakes the SAME fixture
ids to a temp pak, reads it back via PakReader, and deep-compares every
field via the Task 3 ObjectMeshDataEquality comparator. Since the bake
tool and the live client drive the identical MeshExtractor code (MP1a),
this proves the pak ROUND-TRIP preserves what extraction actually
produces on real content — the serializer's job, not a re-verification
of the extraction algorithm itself (the existing Conformance suite owns
that).

Fixture set (>= the plan's minimums): 10 GfxObjs (3 known-tricky ids
reused from Issue119UpNullGfxObjDumpTests - 0x010002B4, 0x010008A8,
0x010014C3 - plus 7 more from dat order), 3 Setups reused from door/
tower conformance fixtures (0x020019FF, 0x020005D8, 0x020003F2), 5
EnvCells walked from the Holtburg landblock 0xA9B40000's
LandBlockInfo.NumCells range (same idiom as
StipplingSurfaceEquivalenceTests).

Skips cleanly when dats are absent via ContentConformanceDats.
ResolveDatDir(), a deliberate small duplicate of
ConformanceDats.ResolveDatDir()'s exact pattern (env var then
Documents/Asheron's Call fallback) since Content.Tests cannot reference
the AcDream.Core.Tests project. ContentTestDatCollectionAdapter is a
third small copy of the IDatReaderWriter dat-access glue (alongside
AcDream.App's internal original and AcDream.Bake's copy) for the same
layering reason (structure rule 6: tests live in the project matching
the layer under test).

Ran for real against the dats on this machine (not just CI-skip path):
1 test, all fixture ids extracted live with zero failures, baked,
read back, and field-for-field identical. Full solution dotnet test:
4106 tests total (43 Content.Tests + 385 Core.Net.Tests + 425
UI.Abstractions.Tests + 722 App.Tests incl. 2 pre-existing skips + 2531
Core.Tests incl. 2 pre-existing skips) — 0 failures.

tests/AcDream.Content.Tests/ContentTestDatCollectionAdapter.cs

@@ -0,0 +1,145 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
+using AcDream.Content;
+using DatReaderWriter;
+using DatReaderWriter.Enums;
+using DatReaderWriter.Lib.IO;
+
+namespace AcDream.Content.Tests;
+
+/// <summary>
+/// Adapts <see cref="DatCollection"/> to <see cref="IDatReaderWriter"/> for
+/// MeshExtractor's constructor, scoped to the equivalence test suite. A
+/// third copy alongside AcDream.App.Rendering.Wb.DatCollectionAdapter
+/// (internal to AcDream.App) and AcDream.Bake.BakeDatCollectionAdapter
+/// (internal to AcDream.Bake) — tests live in the project matching the
+/// layer under test (structure rule 6), so Content.Tests cannot reference
+/// AcDream.Bake just to borrow its copy. Plain dat-access glue, not an
+/// AC-specific algorithm.
+/// </summary>
+internal sealed class ContentTestDatCollectionAdapter : IDatReaderWriter {
+    private readonly DatCollection _dats;
+    private readonly TestDatDatabaseWrapper _portal;
+    private readonly TestDatDatabaseWrapper _cell;
+    private readonly TestDatDatabaseWrapper _highRes;
+    private readonly TestDatDatabaseWrapper _language;
+    private readonly ReadOnlyDictionary<uint, IDatDatabase> _cellRegions;
+
+    public ContentTestDatCollectionAdapter(DatCollection dats) {
+        ArgumentNullException.ThrowIfNull(dats);
+        _dats = dats;
+        _portal = new TestDatDatabaseWrapper(dats.Portal);
+        _cell = new TestDatDatabaseWrapper(dats.Cell);
+        _highRes = new TestDatDatabaseWrapper(dats.HighRes);
+        _language = new TestDatDatabaseWrapper(dats.Local);
+
+        var regions = new Dictionary<uint, IDatDatabase> { [0u] = _cell };
+        _cellRegions = new ReadOnlyDictionary<uint, IDatDatabase>(regions);
+    }
+
+    public string SourceDirectory => _dats.Options.DatDirectory ?? string.Empty;
+
+    public IDatDatabase Portal => _portal;
+    public ReadOnlyDictionary<uint, IDatDatabase> CellRegions => _cellRegions;
+    public IDatDatabase HighRes => _highRes;
+    public IDatDatabase Language => _language;
+
+    public ReadOnlyDictionary<uint, uint> RegionFileMap =>
+        new ReadOnlyDictionary<uint, uint>(new Dictionary<uint, uint>());
+
+    public int PortalIteration => _portal.Iteration;
+    public int CellIteration => _cell.Iteration;
+    public int HighResIteration => _highRes.Iteration;
+    public int LanguageIteration => _language.Iteration;
+
+    public bool TryGetFileBytes(uint regionId, uint fileId, ref byte[] bytes, out int bytesRead) {
+        return _dats.Cell.TryGetFileBytes(fileId, ref bytes, out bytesRead);
+    }
+
+    public IEnumerable<IDatReaderWriter.IdResolution> ResolveId(uint id) {
+        var results = new List<IDatReaderWriter.IdResolution>();
+
+        void CheckDb(TestDatDatabaseWrapper wrapper) {
+            var rawDb = wrapper.RawDatabase;
+            if (rawDb.Tree.TryGetFile(id, out _)) {
+                var type = rawDb.TypeFromId(id);
+                if (type != DBObjType.Unknown) {
+                    results.Add(new IDatReaderWriter.IdResolution(wrapper, type));
+                }
+            }
+        }
+
+        CheckDb(_highRes);
+        CheckDb(_portal);
+        CheckDb(_language);
+        CheckDb(_cell);
+
+        return results;
+    }
+
+    public bool TrySave<T>(T obj, int iteration = 0) where T : IDBObj =>
+        throw new NotSupportedException($"{nameof(ContentTestDatCollectionAdapter)} is read-only.");
+
+    public bool TrySave<T>(uint regionId, T obj, int iteration = 0) where T : IDBObj =>
+        throw new NotSupportedException($"{nameof(ContentTestDatCollectionAdapter)} is read-only.");
+
+    public void Dispose() {
+        // The underlying DatCollection is owned by the caller.
+    }
+}
+
+internal sealed class TestDatDatabaseWrapper : IDatDatabase {
+    private readonly DatDatabase _db;
+    private readonly ConcurrentDictionary<(Type, uint), IDBObj> _cache = new();
+    private readonly object _lock = new();
+
+    public TestDatDatabaseWrapper(DatDatabase db) {
+        ArgumentNullException.ThrowIfNull(db);
+        _db = db;
+    }
+
+    internal DatDatabase RawDatabase => _db;
+
+    public DatDatabase Db => _db;
+    public int Iteration => _db.Iteration?.CurrentIteration ?? 0;
+
+    public IEnumerable<uint> GetAllIdsOfType<T>() where T : IDBObj => _db.GetAllIdsOfType<T>();
+
+    public bool TryGet<T>(uint fileId, [MaybeNullWhen(false)] out T value) where T : IDBObj {
+        if (_cache.TryGetValue((typeof(T), fileId), out var cached)) {
+            value = (T)cached;
+            return true;
+        }
+
+        lock (_lock) {
+            if (_db.TryGet<T>(fileId, out value)) {
+                _cache.TryAdd((typeof(T), fileId), value);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public bool TryGetFileBytes(uint fileId, [MaybeNullWhen(false)] out byte[] value) {
+        lock (_lock) {
+            return _db.TryGetFileBytes(fileId, out value);
+        }
+    }
+
+    public bool TryGetFileBytes(uint fileId, ref byte[] bytes, out int bytesRead) {
+        lock (_lock) {
+            return _db.TryGetFileBytes(fileId, ref bytes, out bytesRead);
+        }
+    }
+
+    public bool TrySave<T>(T obj, int iteration = 0) where T : IDBObj =>
+        throw new NotSupportedException($"{nameof(TestDatDatabaseWrapper)} is read-only.");
+
+    public void Dispose() {
+        // The underlying DatDatabase is owned by DatCollection.
+    }
+}