wip(assembler): round L9 -- LOD1 skips proven-uniform blocks: 95% fewer samples, view ~2% faster

Step-2 (LOD1) tiles of native SurfaceWorld now prove 8-cell blocks uniform from exact heightfield
column extrema over the padded block (cells + normal halo) and skip their density fill; features,
edits, mixed strata and Unknown verdicts still fill. LOD1 samples 42,875 -> 2,063 per tile.
Audit: 80,502 skipped blocks (3 seeds) + 9,216 island blocks force-filled, 0 violations. All
SurfaceWorld and FloatingIslands hashes unchanged at W1/W8/W12, Clang off and GCC default.
Reviewer interleaved W12, no hashing: whole view 1.439 -> 1.409 s. L8 phase probes removed;
--profile-lod-work and --audit-uniform-block-proofs are opt-in.

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

Standalone/Source/StreamBenchmarkPipeline.h

@@ -138,7 +138,8 @@ namespace StandaloneStreamBenchmark
         int32 FarHorizonLOD8InteriorStepVoxels,bool bReportMeshCoverage=false,
         const std::filesystem::path& MeshExportPath={},float CameraYawDegrees=0.0f,
         float CameraPitchDegrees=0.0f,bool bScreenSpaceGate=false,
-        bool bUseSharedColumnCache=true,FVector CameraStepVoxels=FVector::ZeroVector)
+        bool bUseSharedColumnCache=true,FVector CameraStepVoxels=FVector::ZeroVector,
+        bool bAuditUniformBlockProofs=false,bool bReportLodWorkProfile=false)
     {
         using Clock=std::chrono::steady_clock;
         FStandaloneOwnerWorld& World=*OwnerWorld;
@@ -264,6 +265,7 @@ namespace StandaloneStreamBenchmark
         FStandaloneStreamingGenerator Streamer(World,WorkerCount,bHashDensity,nullptr,MaxLevel,
             bSkipUvAndColors,bSkipMaterialGroups,bSkipUV,bSkipColors,&Shape,bProfileColumnOverlap,
             FarHorizonLOD8InteriorStepVoxels,bUseSharedColumnCache);
+        Streamer.SetUniformBlockProofAuditEnabled(bAuditUniformBlockProofs);
         if(bScreenSpaceGate)Streamer.SetMesherStageProfilingEnabled(true);
         const auto StreamStart=Clock::now();
         const FStandaloneStreamingUpdate Update=Streamer.StartWithDesired(Desired);
@@ -330,6 +332,7 @@ namespace StandaloneStreamBenchmark
         std::array<double,9> GroundRefineExclusiveMsByLOD{},CapRefineExclusiveMsByLOD{};
         std::array<double,9> MeshAssemblyMsByLOD{};
         std::array<double,9> SkirtMsByLOD{};
+        std::array<std::uint64_t,9> DensitySamplesByLOD{};
         std::array<std::uint64_t,9> SkirtTrianglesByLOD{};
         std::array<std::uint64_t,9> TileCountByLOD{};
         for(const FVoxelTileKey& Tile:Desired.Tiles)
@@ -354,6 +357,8 @@ namespace StandaloneStreamBenchmark
         GateSampleDistances.fill(std::numeric_limits<double>::infinity());
         Clock::time_point NeighborhoodReady{},FullDetailReady{},WholeViewReady{};
         bool bNeighborhoodReported=false,bFullDetailReported=false;
+        uint64 BlockProofBlocksChecked=0,BlockProofSamplesChecked=0;
+        uint64 BlockProofFallbackBlocks=0,BlockProofUnknownBlocks=0,BlockProofViolations=0;
         while(Finished<Update.DesiredTiles)
         {
             std::vector<FStandaloneCpuTile> Ready=Streamer.TakeReady();
@@ -379,7 +384,16 @@ namespace StandaloneStreamBenchmark
                     CapRefineExclusiveMsByLOD[LOD]+=Tile.CoreDiagnostics.capRefinementExclusiveMilliseconds;
                     MeshAssemblyMsByLOD[LOD]+=Tile.CoreDiagnostics.meshAssemblyMilliseconds;
                     SkirtMsByLOD[LOD]+=Tile.CoreDiagnostics.marchingCubesSkirtMilliseconds;
+                    if(bReportLodWorkProfile)DensitySamplesByLOD[LOD]+=Tile.DensitySamples;
                     SkirtTrianglesByLOD[LOD]+=Tile.SkirtTriangleCount;
+                    if(bAuditUniformBlockProofs)
+                    {
+                        BlockProofBlocksChecked+=Tile.CoreDiagnostics.uniformBlockProofsChecked;
+                        BlockProofSamplesChecked+=Tile.CoreDiagnostics.uniformBlockProofSamplesChecked;
+                        BlockProofFallbackBlocks+=Tile.CoreDiagnostics.uniformBlockProofFallbackBlocks;
+                        BlockProofUnknownBlocks+=Tile.CoreDiagnostics.uniformBlockProofUnknownBlocks;
+                        BlockProofViolations+=Tile.CoreDiagnostics.uniformBlockProofViolations;
+                    }
                     if(bScreenSpaceGate&&Assembly&&Tile.Key.Level>=3&&Tile.Key.Level<9
                         &&!Tile.Vertices.empty()
                         &&StandaloneScreenSpaceGate::TileHasNativeSurface(Tile.Key,*Assembly,
@@ -600,6 +614,13 @@ namespace StandaloneStreamBenchmark
                 GroundRefineExclusiveMsByLOD[LOD],CapRefineExclusiveMsByLOD[LOD],
                 SkirtMsByLOD[LOD],static_cast<unsigned long long>(SkirtTrianglesByLOD[LOD]),
                 MeshAssemblyMsByLOD[LOD]);
+            if(bReportLodWorkProfile)
+            {
+                const double SamplesPerTile=TileCountByLOD[LOD]
+                    ?static_cast<double>(DensitySamplesByLOD[LOD])/TileCountByLOD[LOD]:0.0;
+                std::printf("[WorldAssemblerLODSamples] lod=%zu samples=%llu samples_per_tile=%.1f\n",
+                    LOD,static_cast<unsigned long long>(DensitySamplesByLOD[LOD]),SamplesPerTile);
+            }
         }
         const double NeighborhoodSeconds=std::chrono::duration<double>(NeighborhoodReady-ColdStart).count();
         const double NeighborhoodMeshSeconds=std::chrono::duration<double>(NeighborhoodReady-ShapeReady).count();
@@ -625,6 +646,13 @@ namespace StandaloneStreamBenchmark
             static_cast<unsigned long long>(NativeColumnMisses),
             NativeColumnComputeMilliseconds,NativeClassificationMilliseconds,
             NativeMeshingMilliseconds);
+        if(bAuditUniformBlockProofs)
+            std::printf("[UniformBlockProofAudit] checked_blocks=%llu checked_samples=%llu fallback_blocks=%llu unknown_blocks=%llu violations=%llu\n",
+                static_cast<unsigned long long>(BlockProofBlocksChecked),
+                static_cast<unsigned long long>(BlockProofSamplesChecked),
+                static_cast<unsigned long long>(BlockProofFallbackBlocks),
+                static_cast<unsigned long long>(BlockProofUnknownBlocks),
+                static_cast<unsigned long long>(BlockProofViolations));
 
         bool bHashesPassing=true;
         if(bHashDensity)
@@ -701,6 +729,7 @@ namespace StandaloneStreamBenchmark
         return NeighborhoodFinished==static_cast<int32>(Neighborhood.size())
             &&FullDetailFinished==FullDetailExpected&&Finished==Update.DesiredTiles&&bHashesPassing
             &&(!bProfileColumnOverlap||bColumnOverlapCapturePassing)
-            &&(!bExportRequested||bSceneExportPassing)&&bScreenSpaceGatePassing?0:6;
+            &&(!bExportRequested||bSceneExportPassing)&&bScreenSpaceGatePassing
+            &&(!bAuditUniformBlockProofs||BlockProofViolations==0)?0:6;
     }
 } // namespace StandaloneStreamBenchmark