wip(assembler): round L22 -- one 8 m layout chunk for every strate; real ceiling -> content -> bedrock

StrateLayoutChunkSizeMeters (world setting, default 8 m; owner decision) is resolved once in
the director/adapter and standalone loader; every generator reads the resolved width (no
CHUNK_SIZE / Core-tile inference). Every strate gets solid ceiling and bedrock bands from its
BoundarySealThickness in the shared composition path (diggable by default); faces come from the
shared boundary path. Owner world: FloatingIslands +8..-120 m (128 m, now with a bedrock floor),
SurfaceWorld -120..-632 m (unchanged; full-detail and exact-query hashes equal L21); the 60 m gap is
gone. The strict layout validator passes on the real world, with 0 endpoint dispatch
disagreements. Spawn/benchmark camera derived from route.front. Ledges under the islands gone
(reviewer capture). Evaluator 7, recipe schema 2, layout snapshot 2, FI geometry 4.
Open: SW cap profiles exceed the ceiling band (owner call); transitions still Hard; Unreal
setting/manager/adapter edits uncompiled here.

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

Standalone/Source/StreamBenchmarkPipeline.h

@@ -255,7 +255,7 @@ namespace StandaloneStreamBenchmark
         bool bAuditTileShapeReadiness=false,int DiagnosticSlowShapeCompileMs=0,
         bool bAuditBasePageEquivalence=false,bool bAuditRouteParity=false,
         bool bAuditResolvedLayoutBoundaries=false,
-        const VoxelForgeCore::ResolvedLayoutSnapshotV1* ResolvedLayout=nullptr)
+        const VoxelForgeCore::ResolvedLayoutSnapshotV2* ResolvedLayout=nullptr)
     {
         using Clock=std::chrono::steady_clock;
         FStandaloneOwnerWorld& World=*OwnerWorld;
@@ -470,7 +470,7 @@ namespace StandaloneStreamBenchmark
                 std::vector<std::string> candidates;
                 for(const auto& Stratum:ResolvedLayout->strates)
                 {
-                    const auto contains=[zMicrometres](const VoxelForgeCore::ResolvedLayoutBandV1& Band)
+                    const auto contains=[zMicrometres](const VoxelForgeCore::ResolvedLayoutBandV2& Band)
                     {return Band.presentInCurrentField&&zMicrometres>=Band.bottomMicrometres
                         &&zMicrometres<Band.topMicrometres;};
                     if(contains(Stratum.ceiling))candidates.push_back(Stratum.generatorKind+"/ceiling");
@@ -482,6 +482,14 @@ namespace StandaloneStreamBenchmark
             const std::array<std::int64_t,3> offsets{{
                 -static_cast<std::int64_t>(World.CoreVoxelSizeMicrons),0,
                 static_cast<std::int64_t>(World.CoreVoxelSizeMicrons)}};
+            const std::int64_t stackMinimum=std::min_element(ResolvedLayout->strates.begin(),
+                ResolvedLayout->strates.end(),[](const auto& A,const auto& B)
+                {return A.bedrock.bottomMicrometres<B.bedrock.bottomMicrometres;})
+                ->bedrock.bottomMicrometres;
+            const std::int64_t stackMaximum=std::max_element(ResolvedLayout->strates.begin(),
+                ResolvedLayout->strates.end(),[](const auto& A,const auto& B)
+                {return A.ceiling.topMicrometres<B.ceiling.topMicrometres;})
+                ->ceiling.topMicrometres;
             for(const std::int64_t Endpoint:endpoints)
             for(const std::int64_t Offset:offsets)
             {
@@ -501,16 +509,17 @@ namespace StandaloneStreamBenchmark
                     if(std::find(expectedGenerators.begin(),expectedGenerators.end(),Kind)==expectedGenerators.end())
                         expectedGenerators.push_back(Kind);
                 }
-                if(expected.empty())expectedLabel="uncovered";
+                const float density=Shape.densityAt(position);
+                const bool solid=density<0.0f;
+                const bool outsideStack=zMicrometres<stackMinimum||zMicrometres>=stackMaximum;
+                if(expected.empty())expectedLabel=outsideStack?"outside-stack/air":"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"
+                    ?(!outsideStack||solid)
                     :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),