wip(assembler): round L18 -- FloatingIslands false floors removed; shared strate ceiling

FI geometry v3 drops the all-XY lower boundary seal that created false floors (3.5/8 m); the
ceiling comes from the shared VF_ApplyUpperBoundarySeal and AppendStratumBoundaryCeilings path
for every generator, at each strate's own configured upper boundary (owner: every strate has a
ceiling). Far-LOD ceiling continuity: 0 gaps at LOD4-8. SurfaceWorld bit-identical to L14
(14 configs + 24 m crossing); FI deterministic (28-row matrix); route parity and proofs pass.
Unreal: FI geometryVersion 2->3 and the shared upper-seal helper extracted (UBT compile needed on
the owner PC). Open: small ceiling holes; lower-stratum LOD ring steps seen through the FI void.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CSFYgsdW8ejZSyiMf4qRSX

Standalone/Research/WorldAssemblerM3/Linux18/RunCrossing.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""Run the L18 24 m SurfaceWorld crossing hash matrix."""
+import os
+import re
+import signal
+import subprocess
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[4]
+OUT = ROOT / "Saved/Linux/l18-crossing"
+OUT.mkdir(parents=True, exist_ok=True)
+if not os.sched_getaffinity(0).issubset(set(range(12))):
+    raise SystemExit("run under taskset -c 0-11")
+BINARIES = {
+    "clang-off": ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-linux18-clang",
+    "gcc-default": ROOT / "Standalone/bin/linux/VoxelForgeCoreHeadless-linux18-gcc",
+}
+PATTERN = re.compile(r"^\[Pipeline(?:FullDetailHash|WholeViewHash|LODHash|ExactQueryHash)\].*$", re.M)
+rows = []
+passed = True
+for compiler, binary in BINARIES.items():
+    for workers, repeat in [(1, 1), (8, 1), (12, 1), (12, 2), (12, 3), (12, 4), (12, 5)]:
+        name = f"{compiler}-w{workers}-r{repeat}"
+        logfile = OUT / f"{name}.log"
+        command = ["prlimit", "--as=6442450944", "--", str(binary),
+            str(ROOT / "Standalone/data/owner_world.json"),
+            "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
+            "--stream-hash", "--force-generate", "--clip-radius=3", "--max-clip-level=8",
+            f"--workers={workers}", "--camera=0,-35,-487.94,0,-22",
+            "--camera-step=24,0,0", "--region-crossing", "--recipe=surface-world"]
+        started = time.monotonic()
+        peak_rss = 0
+        with logfile.open("w", encoding="utf-8") as stream:
+            process = subprocess.Popen(command, stdout=stream, stderr=subprocess.STDOUT,
+                                       start_new_session=True)
+            while process.poll() is None:
+                pending = [process.pid]
+                seen = set()
+                while pending:
+                    pid = pending.pop()
+                    if pid in seen:
+                        continue
+                    seen.add(pid)
+                    try:
+                        pending.extend(int(value) for value in
+                            Path(f"/proc/{pid}/task/{pid}/children").read_text().split())
+                        for line in Path(f"/proc/{pid}/status").read_text().splitlines():
+                            if line.startswith("VmRSS:"):
+                                peak_rss = max(peak_rss, int(line.split()[1]))
+                                break
+                    except (FileNotFoundError, PermissionError, ProcessLookupError, ValueError):
+                        pass
+                if time.monotonic() - started > 900:
+                    os.killpg(process.pid, signal.SIGTERM)
+                    try:
+                        process.wait(timeout=5)
+                    except subprocess.TimeoutExpired:
+                        os.killpg(process.pid, signal.SIGKILL)
+                        process.wait()
+                    passed = False
+                    break
+                time.sleep(0.1)
+            code = process.wait()
+        elapsed = time.monotonic() - started
+        actual = PATTERN.findall(logfile.read_text(encoding="utf-8", errors="replace"))
+        ok = code == 0 and len(actual) == 12
+        passed &= ok
+        rows.append((compiler, workers, repeat, code, elapsed, peak_rss, ok, actual))
+        print(f"[CrossingRun] {name} exit={code} seconds={elapsed:.3f} "
+              f"peak_rss_kib={peak_rss} hash_rows={len(actual)} status={'PASS' if ok else 'FAIL'}",
+              flush=True)
+reference = None
+for compiler, workers, repeat, code, elapsed, peak_rss, ok, hashes in rows:
+    if reference is None:
+        reference = hashes
+    elif hashes != reference:
+        passed = False
+        print(f"[CrossingHashMismatch] {compiler} workers={workers} repeat={repeat}", flush=True)
+print(f"[CrossingSummary] rows={len(rows)} expected=14 result={'PASS' if passed else 'FAIL'} "
+      f"path={OUT}", flush=True)
+raise SystemExit(0 if passed and len(rows) == 14 else 1)