wip(assembler): round L23 -- inter-strate passages planned from the resolved layout and carved

After L22 the FI -> SW passage no longer connected the strates (legacy owner-voxel coordinates,
lower end 23 m above SW), and Core never carved passages through the bands. Now the director
plans passages from the resolved layout (PlanResolvedLayoutPassagesV1; deterministic hash of
seed/strates/connection; placement disk from PassageConfig, 8-24 m around (0,0)); shared
composition applies generator field -> bands -> bounded passage carve and support shelf, opening
the bands only along the tunnel. Mouths bind to the strate routes. Capsule audit: 0 blocked /
0 unsupported (325,962 samples FI, 284,319 TunnelNetwork), negative controls detected; all 8
generator kinds exercised. SW away from the passage is bit-identical. Layout V3, evaluator 9.
Open: look not yet natural (stepped tube in FI void, terraced SW arrival); SW-as-upper route
planning fails; Unreal adapter uncompiled.

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

Standalone/Source/StreamBenchmarkHeadless.cpp

@@ -67,6 +67,7 @@ namespace
         std::filesystem::path ResolvedLayoutOutputPath;
         bool ResolvedLayoutOnly=false;
         bool AuditResolvedLayoutBoundaries=false;
+        bool AuditResolvedLayoutPassages=false;
         bool AuditSurfaceClearance=false;
     };
 
@@ -125,6 +126,7 @@ namespace
                     "  --resolved-layout-output=FILE (canonical plan-time layout snapshot)\n"
                     "  --resolved-layout-only (exit after plan and snapshot validation)\n"
                     "  --audit-resolved-layout-boundaries (query Core at each recorded endpoint)\n"
+                    "  --audit-resolved-layout-passages (capsule, support, route-binding and blocked-control audit)\n"
                     "  --audit-surface-clearance (sample biome terrain/caps against the resolved ceiling)\n"
                     "  --auto-surface-camera (place the 27-tile cube on this seed's surface)\n"
                     "  --mesh-coverage (report non-empty tiles and indexed triangles)\n"
@@ -145,6 +147,7 @@ namespace
             if(arg=="--world-assembler-prototype")options.WorldAssemblerPrototype=true;
             else if(arg=="--resolved-layout-only")options.ResolvedLayoutOnly=true;
             else if(arg=="--audit-resolved-layout-boundaries")options.AuditResolvedLayoutBoundaries=true;
+            else if(arg=="--audit-resolved-layout-passages")options.AuditResolvedLayoutPassages=true;
             else if(arg=="--audit-surface-clearance")options.AuditSurfaceClearance=true;
             else if(arg=="--stream-benchmark")options.StreamBenchmark=true;
             else if(arg=="--stream-pipeline")options.StreamPipeline=true;
@@ -332,14 +335,14 @@ int main(int argc,char** argv)
         &&!StandaloneWorldAssemblyPrototype::AttachFloatingIslandWorldAssembly(
             *ownerWorld,ownerJsonRoot,worldAssembly,error))
     {std::fprintf(stderr,"Floating-island assembly setup failed: %s\n",error.c_str());return 2;}
-    VoxelForgeCore::ResolvedLayoutSnapshotV2 resolvedLayout;
+    VoxelForgeCore::ResolvedLayoutSnapshotV3 resolvedLayout;
     {
         const std::string_view variant=options.FloatingIslandsRecipe?"floating-islands":"surface-world";
         if(!StandaloneWorldAssemblyPrototype::BuildResolvedLayoutSnapshot(
             *ownerWorld,worldAssembly,variant,resolvedLayout,error))
         {std::fprintf(stderr,"Resolved-layout snapshot failed: %s\n",error.c_str());return 2;}
         const std::string layoutJson=resolvedLayout.ToJson();
-        const auto roundTrip=VoxelForgeCore::ResolvedLayoutSnapshotV2::FromJson(layoutJson,error);
+        const auto roundTrip=VoxelForgeCore::ResolvedLayoutSnapshotV3::FromJson(layoutJson,error);
         if(!roundTrip||roundTrip->ToJson()!=layoutJson||roundTrip->stableIdentity!=resolvedLayout.stableIdentity)
         {if(error.empty())error="resolved-layout canonical serialization did not round-trip";
          std::fprintf(stderr,"Resolved-layout round trip failed: %s\n",error.c_str());return 2;}
@@ -352,16 +355,16 @@ int main(int argc,char** argv)
             output.write(layoutJson.data(),static_cast<std::streamsize>(layoutJson.size()));
             if(!output){std::fprintf(stderr,"Resolved-layout snapshot write failed: %s\n",options.ResolvedLayoutOutputPath.c_str());return 2;}
         }
-        const auto controls=VoxelForgeCore::AuditResolvedLayoutValidatorV2();
+        const auto controls=VoxelForgeCore::AuditResolvedLayoutValidatorV3();
         std::vector<VoxelForgeCore::ResolvedLayoutIssueV2> compatibilityIssues;
         std::string compatibilityError;
         const bool compatibilityAccepted=resolvedLayout.validate(
-            VoxelForgeCore::ResolvedLayoutValidationModeV2::compatibility,
+            VoxelForgeCore::ResolvedLayoutValidationModeV3::compatibility,
             compatibilityIssues,compatibilityError);
         std::vector<VoxelForgeCore::ResolvedLayoutIssueV2> strictIssues;
         std::string strictError;
         const bool strictAccepted=resolvedLayout.validate(
-            VoxelForgeCore::ResolvedLayoutValidationModeV2::strict,strictIssues,strictError);
+            VoxelForgeCore::ResolvedLayoutValidationModeV3::strict,strictIssues,strictError);
         std::printf("[ResolvedLayoutSnapshot] schema=%u stable_identity=%s strata=%zu bytes=%zu round_trip=PASS\n",
             resolvedLayout.schemaVersion,resolvedLayout.stableIdentity.c_str(),resolvedLayout.strates.size(),layoutJson.size());
         std::printf("[ResolvedLayoutCompatibility] accepted=%s issues=%zu error=%s\n",
@@ -548,5 +551,6 @@ int main(int argc,char** argv)
         options.RegionCrossing,options.AuditTileShapeReadiness,
         options.DiagnosticSlowShapeCompileMs,options.AuditBasePageEquivalence,
         options.AuditRouteParity,options.AuditResolvedLayoutBoundaries,
+        options.AuditResolvedLayoutPassages,
         &resolvedLayout);
 }