wip(assembler): round L21 -- resolved strate layout snapshot + validator (no world change)

Core ResolvedLayoutSnapshotV1 (canonical JSON, stable identity): per strate stable ID, generator,
recipe, interior bounds in metres, ceiling/bedrock bands as Core really applies them, transition
mode/width, dispatch provenance. Validator: compat mode reports today's deviations; strict mode
enforces ceiling -> content -> bedrock -> next ceiling (owner rule), two separate bands, nominal
contiguity, interpenetration only within the declared EVoxelStrateTransition width; 7 negative
controls rejected. Findings: SW built at -120..-632 m although the params say -60 m; a 60 m unowned
gap filled by analytic FI fallback; no active bedrock bands; transitions ignored by Core.
All L19 hashes unchanged (28 + 14 crossing runs). The Unreal adapter exports resolved_layout
(uncompiled here).

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

Standalone/Source/StreamBenchmarkPipeline.h

@@ -253,7 +253,9 @@ namespace StandaloneStreamBenchmark
         bool bAuditUniformBlockProofs=false,bool bReportLodWorkProfile=false,
         bool bRegionCrossing=false,
         bool bAuditTileShapeReadiness=false,int DiagnosticSlowShapeCompileMs=0,
-        bool bAuditBasePageEquivalence=false,bool bAuditRouteParity=false)
+        bool bAuditBasePageEquivalence=false,bool bAuditRouteParity=false,
+        bool bAuditResolvedLayoutBoundaries=false,
+        const VoxelForgeCore::ResolvedLayoutSnapshotV1* ResolvedLayout=nullptr)
     {
         using Clock=std::chrono::steady_clock;
         FStandaloneOwnerWorld& World=*OwnerWorld;
@@ -438,6 +440,89 @@ namespace StandaloneStreamBenchmark
             Streamer.Stop();
             std::fprintf(stderr,"[StreamPipeline] full shape build failed: %s\n",BuildError.c_str());return 2;
         }
+        if(bAuditResolvedLayoutBoundaries)
+        {
+            if(ResolvedLayout==nullptr)
+            {Streamer.Stop();std::fprintf(stderr,"[ResolvedLayoutProbe] missing plan-time snapshot\n");return 2;}
+            std::vector<std::int64_t> endpoints;
+            for(const auto& Stratum:ResolvedLayout->strates)
+            {
+                endpoints.push_back(Stratum.interiorBottomMicrometres);
+                endpoints.push_back(Stratum.interiorTopMicrometres);
+                endpoints.push_back(Stratum.ceiling.bottomMicrometres);
+                endpoints.push_back(Stratum.ceiling.topMicrometres);
+                endpoints.push_back(Stratum.bedrock.bottomMicrometres);
+                endpoints.push_back(Stratum.bedrock.topMicrometres);
+            }
+            for(std::size_t StratumIndex=0;StratumIndex+1<ResolvedLayout->strates.size();++StratumIndex)
+            {
+                const auto& Upper=ResolvedLayout->strates[StratumIndex];
+                if(Upper.transitionMode=="Hard"||Upper.transitionWidthMicrometres<=0)continue;
+                endpoints.push_back(Upper.interiorBottomMicrometres-Upper.transitionWidthMicrometres);
+                endpoints.push_back(Upper.interiorBottomMicrometres+Upper.transitionWidthMicrometres);
+            }
+            std::sort(endpoints.begin(),endpoints.end());
+            endpoints.erase(std::unique(endpoints.begin(),endpoints.end()),endpoints.end());
+            std::uint64_t probes=0,disagreements=0;
+            const double CoreVoxelMicrometres=std::max<std::uint32_t>(1,World.CoreVoxelSizeMicrons);
+            const auto expectedAt=[&](std::int64_t zMicrometres)
+            {
+                std::vector<std::string> candidates;
+                for(const auto& Stratum:ResolvedLayout->strates)
+                {
+                    const auto contains=[zMicrometres](const VoxelForgeCore::ResolvedLayoutBandV1& Band)
+                    {return Band.presentInCurrentField&&zMicrometres>=Band.bottomMicrometres
+                        &&zMicrometres<Band.topMicrometres;};
+                    if(contains(Stratum.ceiling))candidates.push_back(Stratum.generatorKind+"/ceiling");
+                    if(contains(Stratum.content))candidates.push_back(Stratum.generatorKind+"/content");
+                    if(contains(Stratum.bedrock))candidates.push_back(Stratum.generatorKind+"/bedrock");
+                }
+                return candidates;
+            };
+            const std::array<std::int64_t,3> offsets{{
+                -static_cast<std::int64_t>(World.CoreVoxelSizeMicrons),0,
+                static_cast<std::int64_t>(World.CoreVoxelSizeMicrons)}};
+            for(const std::int64_t Endpoint:endpoints)
+            for(const std::int64_t Offset:offsets)
+            {
+                const std::int64_t zMicrometres=Endpoint+Offset;
+                const double zVoxel=static_cast<double>(zMicrometres)/CoreVoxelMicrometres;
+                const VoxelForgeCore::Vec3d position{0.0,0.0,zVoxel};
+                const std::string actual=Shape.densityDispatchPathAt(position);
+                const auto expected=expectedAt(zMicrometres);
+                std::string expectedLabel;
+                std::vector<std::string> expectedGenerators;
+                for(const auto& Candidate:expected)
+                {
+                    if(!expectedLabel.empty())expectedLabel+=',';
+                    expectedLabel+=Candidate;
+                    const auto Separator=Candidate.find('/');
+                    const std::string Kind=Candidate.substr(0,Separator);
+                    if(std::find(expectedGenerators.begin(),expectedGenerators.end(),Kind)==expectedGenerators.end())
+                        expectedGenerators.push_back(Kind);
+                }
+                if(expected.empty())expectedLabel="uncovered";
+                std::string actualGenerator;
+                if(actual=="SurfaceWorld-native"||actual=="SurfaceWorld-legacy")actualGenerator="SurfaceWorld";
+                else if(actual=="FloatingIslands-native")actualGenerator="FloatingIslands";
+                else if(actual.rfind("compiled-analytic/",0)==0)actualGenerator=actual.substr(18);
+                const bool mismatch=expected.empty()
+                    ?actual!="compiled-analytic/fallback"
+                    :std::find(expectedGenerators.begin(),expectedGenerators.end(),actualGenerator)==expectedGenerators.end();
+                const float density=Shape.densityAt(position);
+                const bool solid=density<0.0f;
+                ++probes;disagreements+=mismatch?1u:0u;
+                std::printf("[ResolvedLayoutProbe] endpoint_um=%lld offset_um=%lld z_m=%.3f expected=%s actual=%s density=%.7g occupancy=%s disagreement=%s\n",
+                    static_cast<long long>(Endpoint),static_cast<long long>(Offset),
+                    static_cast<double>(zMicrometres)/1000000.0,expectedLabel.c_str(),actual.c_str(),density,
+                    solid?"solid":"air",mismatch?"YES":"no");
+            }
+            std::printf("[ResolvedLayoutProbeSummary] probes=%llu disagreements=%llu status=%s\n",
+                static_cast<unsigned long long>(probes),static_cast<unsigned long long>(disagreements),
+                disagreements==0?"PASS":"DEVIATIONS_RECORDED");
+            Streamer.Stop();
+            return 0;
+        }
         const auto ShapeReady=Clock::now();
         const double ShapeSeconds=std::chrono::duration<double>(ShapeReady-ShapeBuildStart).count();
         if(bAuditTileShapeReadiness)