move FactoryState ownership out of BuildingSystem to Simulation

Simulation (and ArenaSimulation in the balancing tool) now owns the factory's
world data; BuildingSystem holds a reference to it. This is what lets the systems
that operate on the data be handed the same state — phase 3's construction and
deconstruction systems, and later the ecs/system/ classes that today take a
BuildingSystem& only to query it.

reset() clears the state alongside m_admin and m_beltSystem, matching how the
subsystems were already rebuilt from scratch.

Falls short of the tick-argument form I sketched: BuildingSystem still reaches
the data through a member reference rather than a parameter. Making it truly
stateless means the const query surface has to find the data some other way, and
that surface is large — findBuilding alone has 64 call sites, with findSite,
getAllBuildings, getAllSites, isTileOccupied and the rest behind it. Doing that
needs a queries facade behind Simulation::getBuildings() so the callers do not
all move, which is its own decision rather than a side effect of this one.

The constructor gains a parameter, so the four owners and the three test fixtures
that build a BuildingSystem directly are updated; the 33 files that only use one
are untouched.

Verified with a golden-checksum capture before and after — all four sample ticks
identical.

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

src/lib/sim/BuildingSystem.cpp

@@ -23,6 +23,7 @@ bool inputLaneEntryFree(const std::vector<BeltItemSlot>& lane)
 }  // namespace
 
 BuildingSystem::BuildingSystem(const GameConfig& config,
+                               FactoryState& state,
                                BeltSystem& belts,
                                std::function<BuildingId()> allocateBuildingId,
                                std::function<void(int)> addBuildingBlocks,
@@ -31,6 +32,7 @@ BuildingSystem::BuildingSystem(const GameConfig& config,
                                std::function<bool(const std::string&)> isItemUnlocked,
                                std::mt19937& rng)
     : m_config(config)
+    , m_state(state)
     , m_belts(belts)
     , m_allocateBuildingId(std::move(allocateBuildingId))
     , m_addBuildingBlocks(std::move(addBuildingBlocks))

src/lib/sim/BuildingSystem.h

@@ -47,6 +47,7 @@ class BuildingSystem
 {
 public:
     BuildingSystem(const GameConfig& config,
+                   FactoryState& state,
                    BeltSystem& belts,
                    std::function<BuildingId()> allocateBuildingId,
                    std::function<void(int)> addBuildingBlocks,
@@ -285,6 +286,11 @@ private:
                             QPoint anchor) const;
 
     const GameConfig&                              m_config;
+
+    // The factory's world data — buildings, queued work, tile ownership. Owned by
+    // Simulation, not by this system (see FactoryState.h).
+    FactoryState&                                  m_state;
+
     BeltSystem&                                    m_belts;
     std::function<BuildingId()>                      m_allocateBuildingId;
     std::function<void(int)>                       m_addBuildingBlocks;
@@ -293,9 +299,4 @@ private:
     std::function<bool(const std::string&)>        m_isItemUnlocked;
     std::mt19937&                                  m_rng;
     int                                            m_asteroidWidth_tiles;
-
-    // The factory's world data — buildings, queued work, tile ownership. Held here
-    // for now; the intent is for Simulation to own it and pass it into the tick
-    // methods, leaving this system stateless over it (see FactoryState.h).
-    FactoryState m_state;
 };

src/lib/sim/FactoryState.h

@@ -31,8 +31,11 @@ struct DeconstructionEntry
 // data/behaviour split the ecs/system/ classes already follow, where world data
 // arrives as a tick argument instead of being owned by the system.
 //
-// Owned by BuildingSystem for now. The intent is to hand ownership to Simulation
-// and pass this into the tick methods, so the systems become stateless over it.
+// Owned by Simulation (and by ArenaSimulation in the balancing tool), not by the
+// systems that operate on it. BuildingSystem holds a reference. The remaining step
+// is to pass this into the tick methods instead, so the systems become stateless
+// over it — that one is gated on the query surface, which today reaches the data
+// through BuildingSystem's ~180 const call sites.
 struct FactoryState
 {
     std::vector<Building>           buildings;

src/lib/sim/Simulation.cpp

@@ -94,6 +94,7 @@ void Simulation::reset(unsigned int seed)
     m_pendingSchematicChoices.clear();
 
     m_admin.clear();
+    m_factoryState = FactoryState{};
     m_beltSystem = BeltSystem(m_config.world.beltSpeed_tps);
     initializeSubsystems();
 
@@ -105,6 +106,7 @@ void Simulation::initializeSubsystems()
 {
     m_buildingSystem = std::make_unique<BuildingSystem>(
         m_config,
+        m_factoryState,
         m_beltSystem,
         [this]() { return allocateBuildingId(); },
         [this](int amount) { m_buildingBlocksStock += amount; },

src/lib/sim/Simulation.h

@@ -9,6 +9,7 @@
 #include <QPoint>
 
 #include "BeltSystem.h"
+#include "FactoryState.h"
 #include "EntityAdmin.h"
 #include "entt/entity/entity.hpp"
 #include "SchematicChoiceOption.h"
@@ -209,6 +210,9 @@ private:
     UnlockState m_unlockState;
 
     EntityAdmin                       m_admin;
+    // The factory's world data. Owned here, not by BuildingSystem, so the systems
+    // that operate on it can be handed the same state (see FactoryState.h).
+    FactoryState                      m_factoryState;
     BeltSystem                        m_beltSystem;
     std::unique_ptr<BuildingSystem>   m_buildingSystem;
     std::unique_ptr<ShipSystem>       m_shipSystem;