feat(core+app): per-cell terrain texture blending (Phase 3c.4)

The visual-win commit that wires up the Phase 3c.1/.2/.3 building blocks:
Holtburg's terrain now uses AC's real per-cell texture-merge blend
(base + up to 3 terrain overlays + up to 2 road overlays, with alpha
masks from the alpha atlas) instead of the flat per-vertex single-layer
atlas lookup that preceded it.

Geometry rewrite:
  - New TerrainVertex struct (40 bytes): Position(vec3) + Normal(vec3) +
    Data0..3 (4x uint32 packed blend recipe)
  - LandblockMesh.Build is now cell-based: iterates 8x8 cells instead of
    the old 9x9 vertex grid, emits 6 vertices per cell (two triangles),
    384 total vertices per landblock
  - For each cell: extract 4-corner terrain/road values → GetPalCode →
    BuildSurface (cached across landblocks via a shared surfaceCache) →
    FillCellData → split direction from CalculateSplitDirection → emit
    6 vertices in the exact gl_VertexID % 6 order WorldBuilder's vertex
    shader expects
  - Per-vertex normals preserved via Phase 3b central-difference
    precomputation on the 9x9 heightmap, interpolated smoothly across
    the cell (we deliberately didn't adopt WorldBuilder's dFdx/dFdy
    flat-shade approach — Phase 3a/3b user-tuned lighting was worth
    keeping)

Renderer rewrite:
  - TerrainRenderer VAO: vec3 Position, vec3 Normal, 4x uvec4 byte
    attributes for Data0..3. The uvec4-of-bytes read pattern matches
    Landscape.vert so the ported shader math stays byte-for-byte
    identical to WorldBuilder's.
  - Binds both atlases: terrain atlas on unit 0 (uTerrain), alpha atlas
    on unit 1 (uAlpha)

Shader rewrite (ports of WorldBuilder Landscape.vert/.frag, trimmed):
  - terrain.vert: unpacks the 4 data bytes + rotation bits, derives the
    cell corner from gl_VertexID % 6 + splitDir, rotates the cell-local
    UV per overlay's rotation field, and computes world-space normal
    for the fragment shader
  - terrain.frag: maskBlend3 three-layer alpha-weighted composite for
    terrain overlays, inverted-alpha road combine, final composite
    base * (1-ovlA)*(1-rdA) + ovl * ovlA*(1-rdA) + road * rdA. Phase
    3a/3b directional lighting applied on top (SUN_DIR, AMBIENT=0.25,
    DIFFUSE=0.75, in sync with mesh.frag).
  - Editor uniforms (grid, brush, unwalkable slopes) deliberately
    omitted — not applicable to a game client
  - Per-texture tiling factor hardcoded to 1.0 for now (WorldBuilder
    reads it from uTexTiling[36] uploaded from the dats); one tile per
    cell = 8 tiles per landblock-side, slightly coarser than the old
    ~2x-per-cell tiling. Tunable via the TILE constant if needed.

TerrainAtlas grew parallel TCode/RCode lists (CornerAlphaTCodes,
SideAlphaTCodes, RoadAlphaRCodes) so TerrainBlendingContext can be
built without the mesh loader touching the dats directly.

GameWindow builds a TerrainBlendingContext once, shares a Dictionary
<uint, SurfaceInfo> surfaceCache across all 9 landblocks. Output:
"terrain: 137 unique palette codes across 9 landblocks" — avg ~15
unique per landblock, cache reuse healthy.

LandblockMeshTests rewritten for 384-vertex layout. 77/77 tests green.
Visual smoke run launches clean: no shader compile/link errors, no
GL warnings, terrain renders to the screen.

User visual verification is the final acceptance gate for Phase 3c.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

src/AcDream.App/Rendering/GameWindow.cs

@@ -149,21 +149,47 @@ public sealed class GameWindow : IDisposable
         int centerX = (int)((centerLandblockId >> 24) & 0xFFu);
         int centerY = (int)((centerLandblockId >> 16) & 0xFFu);
 
+        // Shared blending context + SurfaceInfo cache across all loaded
+        // landblocks. Palette codes are deterministic so two landblocks that
+        // happen to share a cell layout hit the cache instead of rebuilding.
+        var terrainTypeToLayerBytes = new Dictionary<uint, byte>(terrainAtlas.TerrainTypeToLayer.Count);
+        foreach (var kvp in terrainAtlas.TerrainTypeToLayer)
+            terrainTypeToLayerBytes[kvp.Key] = (byte)kvp.Value;
+
+        const uint RoadTypeEnumValue = 0x20;  // TerrainTextureType.RoadType
+        byte roadLayer = terrainTypeToLayerBytes.TryGetValue(RoadTypeEnumValue, out var rl)
+            ? rl
+            : AcDream.Core.Terrain.SurfaceInfo.None;
+
+        var blendCtx = new AcDream.Core.Terrain.TerrainBlendingContext(
+            TerrainTypeToLayer: terrainTypeToLayerBytes,
+            RoadLayer: roadLayer,
+            CornerAlphaLayers: terrainAtlas.CornerAlphaLayers,
+            SideAlphaLayers:   terrainAtlas.SideAlphaLayers,
+            RoadAlphaLayers:   terrainAtlas.RoadAlphaLayers,
+            CornerAlphaTCodes: terrainAtlas.CornerAlphaTCodes,
+            SideAlphaTCodes:   terrainAtlas.SideAlphaTCodes,
+            RoadAlphaRCodes:   terrainAtlas.RoadAlphaRCodes);
+
+        var surfaceCache = new Dictionary<uint, AcDream.Core.Terrain.SurfaceInfo>();
+
         foreach (var lb in worldView.Landblocks)
         {
+            uint lbX = (lb.LandblockId >> 24) & 0xFFu;
+            uint lbY = (lb.LandblockId >> 16) & 0xFFu;
+
             var meshData = AcDream.Core.Terrain.LandblockMesh.Build(
-                lb.Heightmap, heightTable, terrainAtlas.TerrainTypeToLayer);
+                lb.Heightmap, lbX, lbY, heightTable, blendCtx, surfaceCache);
 
             // Compute world origin for this landblock relative to the center.
-            int lbX = (int)((lb.LandblockId >> 24) & 0xFFu);
-            int lbY = (int)((lb.LandblockId >> 16) & 0xFFu);
             var origin = new System.Numerics.Vector3(
-                (lbX - centerX) * 192f,
-                (lbY - centerY) * 192f,
+                ((int)lbX - centerX) * 192f,
+                ((int)lbY - centerY) * 192f,
                 0f);
 
             _terrain.AddLandblock(meshData, origin);
         }
+        Console.WriteLine($"terrain: {surfaceCache.Count} unique palette codes across {worldView.Landblocks.Count} landblocks");
 
         _textureCache = new TextureCache(_gl, _dats);
         _staticMesh = new StaticMeshRenderer(_gl, _meshShader, _textureCache);