parity: Unreal and headless resolve the same four-strate plan (L70, v214)

- Export commandlet writes the live Core adapter's world_assembly + resolved layout pair;
  the headless owner path imports that pair (manifest/layout equal, layout_chunk_width_q
  validated). owner_world.json re-exported from the owner's staged assets on the Linux host.
- Adapter SW route: Core clearance/radius floors, 0.5 m support search, outward-facing
  tie-break; passage mouth/mid radius floors match Core (36/24 owner voxels).
- FI in Unreal now uses the legacy (compiled analytic) generator unless a plan is imported:
  the auto native-FI plan failed the passage audit on the owner plan (1843 blocked samples,
  945 open-air violations). Owner decides whether native FI returns.
- In-engine spawn traces per strate (3 each): SW GenerateTile 42.7 worker-s vs 20.1 headless
  for equal tile counts; LOD0 p95 45-169 ms in UE.
- Fast tier green; all three passages pass on the shared plan.

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

Standalone/Source/StreamBenchmarkHeadless.cpp

@@ -1695,6 +1695,18 @@ int main(int argc,char** argv)
         &&!OverrideTransitions(ownerJsonRoot,options.TransitionModeOverride,
             options.TransitionWidthChunksOverride,error))
     {std::fprintf(stderr,"Transition fixture override failed: %s\n",error.c_str());return 2;}
+    const bool hasExportedAssembly=ownerJsonRoot.Get("core_world_assembly_json").IsString();
+    const bool hasExportedLayout=ownerJsonRoot.Get("resolved_layout_json").IsString();
+    if(hasExportedAssembly!=hasExportedLayout)
+    {std::fprintf(stderr,"Owner export has only half of its Unreal-resolved Core plan.\n");return 2;}
+    const bool useExportedCorePlan=hasExportedAssembly
+        &&!options.HasSeedOverride
+        &&!options.FloatingIslandsRecipe
+        &&!options.CavesRecipe
+        &&!options.LatticeRecipe
+        &&options.TransitionModeOverride<0
+        &&options.TransitionWidthChunksOverride<0;
+    ownerWorld->bHasUnrealResolvedCorePlan=useExportedCorePlan;
     if(!StandaloneOwnerLoader::Resolve(ownerJsonRoot,*ownerWorld,error))
     {std::fprintf(stderr,"Owner data load failed: %s\n",error.c_str());return 2;}
     std::printf("[ColdTimeline] stage=owner_data_load end_ms=%.3f\n",
@@ -1720,10 +1732,20 @@ int main(int argc,char** argv)
 
     const auto planStart=Clock::now();
     VoxelForgeCore::WorldAssemblyManifest worldAssembly;
-    if(!StandaloneWorldAssemblyPrototype::AttachRound1WorldAssemblyPrototype(
+    if(useExportedCorePlan)
+    {
+        if(!StandaloneWorldAssemblyPrototype::ImportExportedCoreWorldAssembly(
+                ownerJsonRoot,worldAssembly,error))
+        {std::fprintf(stderr,"Unreal-resolved Core plan import failed: %s\n",error.c_str());return 2;}
+        std::printf("[WorldAssemblerPlanSource] source=owner_export/unreal_core_adapter manifest_hash=%016llx layout_chunk_width_q=%lld surface_strates=%zu floating_islands=%zu\n",
+            static_cast<unsigned long long>(worldAssembly.contentHash),
+            static_cast<long long>(worldAssembly.recipe.layoutChunkWidthSubvoxels),
+            worldAssembly.plan.strates.size(),worldAssembly.floatingIslands.size());
+    }
+    else if(!StandaloneWorldAssemblyPrototype::AttachRound1WorldAssemblyPrototype(
         *ownerWorld,ownerJsonRoot,error,{},&worldAssembly))
     {std::fprintf(stderr,"World assembler prototype setup failed: %s\n",error.c_str());return 2;}
-    if(options.FloatingIslandsRecipe
+    if(!useExportedCorePlan&&options.FloatingIslandsRecipe
         &&!StandaloneWorldAssemblyPrototype::AttachFloatingIslandWorldAssembly(
             *ownerWorld,ownerJsonRoot,worldAssembly,error))
     {std::fprintf(stderr,"Floating-island assembly setup failed: %s\n",error.c_str());return 2;}
@@ -1757,9 +1779,17 @@ int main(int argc,char** argv)
             ?"lattice/"+std::to_string(options.LatticeStrateIndex)
             :options.CavesRecipe?"caves"
                 :options.FloatingIslandsRecipe?"floating-islands":"surface-world";
-        if(!StandaloneWorldAssemblyPrototype::BuildResolvedLayoutSnapshot(
-            *ownerWorld,worldAssembly,variant,resolvedLayout,error))
+        const bool layoutResolved=useExportedCorePlan
+            ?StandaloneWorldAssemblyPrototype::ImportExportedResolvedLayout(
+                ownerJsonRoot,resolvedLayout,error)
+            :StandaloneWorldAssemblyPrototype::BuildResolvedLayoutSnapshot(
+                *ownerWorld,worldAssembly,variant,resolvedLayout,error);
+        if(!layoutResolved)
         {std::fprintf(stderr,"Resolved-layout snapshot failed: %s\n",error.c_str());return 2;}
+        if(useExportedCorePlan
+            &&!StandaloneWorldAssemblyPrototype::ValidateExportedCorePlanMatchesOwner(
+                *ownerWorld,worldAssembly,resolvedLayout,error))
+        {std::fprintf(stderr,"Unreal-resolved Core plan/owner slot validation failed: %s\n",error.c_str());return 2;}
         if(!std::holds_alternative<std::nullptr_t>(ownerJsonRoot.Get("motif_family_override").Data))
         {
             std::vector<VoxelForgeCore::ResolvedLayoutStampRequestV1> requests;