skip: passage proof bounds include wall/floor relief (L75 soundness fix); FI -7.6%

L74's passage bound omitted the 0.21 m wall relief and 0.20 m floor relief, so its whole-tile
proof was unsound in principle (no tested view hit it). Passage support is now bounded per route
segment by four parameter-subinterval boxes using Catmull-Rom derivative extrema, local max
radius and relief padding. Stratum slicing only at LOD0-2 in FI/VS. Legacy sub-tile block
certificates are audit-only (runtime version was slower). TN regression (-80,-20,-3218) kept.

Exact full-grid vs skip hashes on every tile, 4 views, Clang/GCC, W1/W8/W12; control caught;
80-camera sweep 0 violations. Whole view vs c67b200: SW -1.3%, FI -7.6%, TN -2.3%, VS +0.2%.
Compiles in the Linux UE host (VFHostEditor, 27/27 actions).

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

Standalone/Source/StreamingWorld.h

@@ -891,6 +891,9 @@ private:
             Options.bandMinZVoxel=Job.BandZMin;Options.bandMaxZVoxel=Job.BandZMax;
             Options.hashDensity=bHashDensity;
             Options.allowUniformSkipsWhenHashing=bHashDensity&&bAllowUniformSkipsWhenHashing;
+            // The reference hash mode must materialize every density sample, including
+            // tiles whose sub-block intervals independently prove a uniform sign.
+            Options.forceFullDensityCapture=bHashDensity&&!bAllowUniformSkipsWhenHashing;
             Options.skipUvAndColors=bSkipUvAndColors;
             Options.skipMaterialGroups=bSkipMaterialGroups;Options.skipUv=bSkipUV;Options.skipColors=bSkipColors;
             Options.captureColumnCoordinates=bCaptureColumnCoordinates;

Standalone/Source/VoxelForge/Private/VoxelMarchingCubesMesher.cpp

@@ -17,6 +17,7 @@
 #include "Misc/CommandLine.h"
 #include <atomic>
 #include <bit>
+#include <cstdlib>
 #include <immintrin.h>
 #include <unordered_map>
 
@@ -28,6 +29,15 @@ namespace
         GVoxelForgeUseOperatorBlock,
         TEXT("Use the operator-major density block path for non-shared mesher grids."));
     bool GVoxelForgeBlockSwitchParsed = false;
+    bool VF_IsL75TnBlockRegressionEnabled()
+    {
+        static const bool Enabled=[]
+        {
+            const char* Value=std::getenv("VOXELFORGE_L75_TN_BLOCK_REGRESSION");
+            return Value&&Value[0]=='1'&&Value[1]=='\0';
+        }();
+        return Enabled;
+    }
     int32 GVoxelForgeRawSkirtsForAudit = 0;
     bool GVoxelForgeRawSkirtsSwitchParsed = false;
 
@@ -644,10 +654,44 @@ FVoxelMeshData UVoxelMarchingCubesMesher::GenerateMesh(FIntVector OriginVoxels,
                         bBlockUnknown=ShapeVerdict.bUnknown;
                         bBlockNative=ShapeVerdict.bNativeSurface;
                         bBlockProofSafe=ShapeVerdict.bSkipSafe;
+                        if(VF_IsL75TnBlockRegressionEnabled())
+                        {
+                            constexpr int32 ProbeX=-80,ProbeY=-20,ProbeZ=-3218;
+                            const auto IsCapturedGridPoint=[&](int32 Value,int32 Start)
+                            {
+                                const int32 Delta=Value-Start;
+                                return Delta%Step==0&&Delta/Step>=-1
+                                    &&Delta/Step<=BlockCells+1;
+                            };
+                            if(IsCapturedGridPoint(ProbeX,BlockOrigin.X)
+                                &&IsCapturedGridPoint(ProbeY,BlockOrigin.Y)
+                                &&IsCapturedGridPoint(ProbeZ,BlockOrigin.Z))
+                            {
+                                const float Density=ShapeWorldContext->DensityAtLattice(
+                                    ProbeX,ProbeY,ProbeZ);
+                                const std::string Dispatch=ShapeWorldContext->DensityDispatchPathAt(
+                                    static_cast<float>(ProbeX),static_cast<float>(ProbeY),
+                                    static_cast<float>(ProbeZ));
+                                const EVoxelTileClass GeneratorVerdict=Generator->ClassifyTile(
+                                    BlockOrigin,Step,BlockCells);
+                                const char* Label=Verdict==EVoxelTileClass::AllSolid?"solid":
+                                    Verdict==EVoxelTileClass::AllAir?"air":"mixed";
+                                const char* GeneratorLabel=GeneratorVerdict==EVoxelTileClass::AllSolid
+                                    ?"solid":GeneratorVerdict==EVoxelTileClass::AllAir?"air":"mixed";
+                                std::printf("[L75TNBlockRegression] tile_origin=(%d,%d,%d) step=%d cells=%d block=(%d,%d,%d) verdict=%s proof_safe=%d unknown=%d density=%.9g dispatch=%s generator_verdict=%s\n",
+                                    OriginVoxels.X,OriginVoxels.Y,OriginVoxels.Z,Step,
+                                    CellsPerAxis,BlockX,BlockY,BlockZ,Label,
+                                    bBlockProofSafe?1:0,bBlockUnknown?1:0,Density,
+                                    Dispatch.c_str(),GeneratorLabel);
+                            }
+                        }
                         if((Verdict==EVoxelTileClass::AllSolid
                                 ||Verdict==EVoxelTileClass::AllAir)
                             &&!bBlockProofSafe)
                         {
+                            // An uncertified uniform candidate makes the parent block grid
+                            // unusable as a sampling certificate. Keep the committed fallback:
+                            // fill the full density grid for this tile.
                             bCanSkipProofBlockGrid=false;
                             bAllRelevantBlocksProofSafe=false;
                         }