Fix HD atlas sampling and protected terrain joins

Add rational atlas cells and bounded authenticated Original-detail retention with standalone synthetic regression checks. Rebuild Linux and Windows runtimes; validate all 5384 supplied frames and preserve three exact 1080p regression controls.

tests/grid_sampler_reference.py

@@ -0,0 +1,62 @@
+"""Synthetic-only scalar model of the proposed opt-in kernel; no game/art IO."""
+import math
+import struct
+
+def f32(value):
+    return struct.unpack('<f', struct.pack('<f', value))[0]
+
+def lanczos(value):
+    if value == 0:
+        return 1.0
+    if abs(value) >= 3:
+        return 0.0
+    value *= math.pi
+    return math.sin(value) / value * (math.sin(value / 3) / (value / 3))
+
+def axis_weights(start, end, output):
+    start, end = float(start), float(end)
+    scale = max((end - start) / output, 1.0)
+    rows = []
+    for destination in range(output):
+        center = start + (destination + 0.5) * (end - start) / output
+        lower = max(math.floor(center - 3 * scale), math.floor(start))
+        upper = min(math.ceil(center + 3 * scale), math.ceil(end))
+        weights = []
+        for index in range(lower, upper):
+            overlap = max(0.0, min(index + 1, end) - max(index, start))
+            weight = lanczos((index + 0.5 - center) / scale) * overlap
+            if weight:
+                weights.append((index, weight))
+        total = sum(value for _, value in weights)
+        if not math.isfinite(total) or abs(total) <= 1e-12:
+            raise ValueError('invalid rational atlas filter weights')
+        rows.append([(index, f32(value / total)) for index, value in weights])
+    return rows
+
+def sample_fractional(pixels, geometry):
+    left, top, right, bottom = geometry['bounds']
+    width, height = geometry['resident']
+    _, first_y, _, last_y = geometry['pixels']
+    x_weights = axis_weights(left, right, width)
+    y_weights = axis_weights(top, bottom, height)
+    horizontal = []
+    for source_y in range(first_y, last_y):
+        row = []
+        for weights in x_weights:
+            sample = [0.0] * 4
+            for source_x, weight in weights:
+                for channel in range(4):
+                    sample[channel] = f32(sample[channel] + f32(pixels[source_y][source_x][channel] * weight))
+            row.append(sample)
+        horizontal.append(row)
+    result = []
+    for weights in y_weights:
+        row = []
+        for x in range(width):
+            sample = [0.0] * 4
+            for source_y, weight in weights:
+                for channel in range(4):
+                    sample[channel] = f32(sample[channel] + f32(horizontal[source_y - first_y][x][channel] * weight))
+            row.append(tuple(math.floor(min(255, max(0, value)) + 0.5) for value in sample))
+        result.append(row)
+    return result