feat(engine): stitch per-object selector plans for sequential prints

Sequential (by-object) prints were incoherent with the per-layer filament
selector (enable_filament_dynamic_map): the by-object branch published a
static grouping while each per-object ToolOrdering independently ran the
dynamic planner from an empty nozzle status and wrote its own map to the
config (one write per object, last object wins). The exported toolchange
sequences then disagreed with the published result that drives the
per-layer maps, placeholders, and selector emission.

Now the by-object branch, when the selector is enabled, plans each unique
object once — threading the physical nozzle occupancy and the previous
object's last filament into the next plan — stitches the per-object
per-layer nozzle maps into one print-wide result (gap-filled by the new
normalize_nozzle_map_per_layer so any layer index resolves a filament's
nozzle consistently), publishes it, and writes the derived extruder map
back once. The plans are cached on the Print and g-code export consumes
the cache: the ToolOrdering seed changes the plan input (dontcare
assignment, first-layer reorder), so a fresh export-time construction
could re-plan differently from the published stitch. The per-object
dynamic write-back is gated off for sequential prints.

Every change is gated behind is_dynamic_group_reorder(); no profile sets
the flag, so the static fleet's instruction stream is unchanged (20/20
pinned-slice byte gate identical, incl. the by-object repro sliced twice).

Tests: normalize unit coverage (carry-forward, back-fill, ragged input),
stitched-blocks selector detection, and an end-to-end by-object selector
slice (apply -> process -> export) asserting the published stitched
result, one cached plan per object, the config write-back, and a clean
export. Suites green (libslic3r 48958/165, fff_print 633/60).

src/libslic3r/Print.hpp

@@ -1028,13 +1028,20 @@ public:
     std::shared_ptr<MultiNozzleUtils::NozzleGroupResultBase> get_nozzle_group_result() const { return m_nozzle_group_result; }
     std::shared_ptr<MultiNozzleUtils::LayeredNozzleGroupResult> get_layered_nozzle_group_result() const;
 
-    // True only when the printer opts into the per-layer filament selector
+    // True only when the project opts into the per-layer filament selector
     // (enable_filament_dynamic_map) in auto-for-flush mode on a multi-extruder machine. Gates the
-    // dynamic (per-layer) regroup branch in ToolOrdering::reorder_extruders_for_minimum_flush_volume.
-    // Closed for every current profile, so the static grouping path (byte-identical output) is the
-    // only one taken by the shipping fleet.
+    // dynamic (per-layer) regroup branch in ToolOrdering::reorder_extruders_for_minimum_flush_volume,
+    // the sequential (by-object) plan stitching in Print::process, and GCode's use of the cached
+    // sequential plans. No profile sets the flag, so the static grouping path (byte-identical
+    // output) is the only one taken unless the user enables the selector.
     bool is_dynamic_group_reorder() const;
 
+    // Per-object tool orderings planned by the sequential (by-object) selector regroup with
+    // cross-object nozzle-status threading. GCode export must consume these exact plans: a fresh
+    // per-object construction would re-plan from a different seed and diverge from the published
+    // stitched result. Empty on the static path.
+    const std::map<const PrintObject*, ToolOrdering>& sequential_dynamic_orderings() const { return m_sequential_dynamic_orderings; }
+
     const std::vector<std::vector<DynamicPrintConfig>>& get_extruder_filament_info() const { return m_extruder_filament_info; }
     void set_extruder_filament_info(const std::vector<std::vector<DynamicPrintConfig>>& filament_info) { m_extruder_filament_info = filament_info; }
 
@@ -1271,6 +1278,10 @@ private:
     // Logical (extruder, nozzle) grouping result, set by ToolOrdering during reorder.
     std::shared_ptr<MultiNozzleUtils::NozzleGroupResultBase> m_nozzle_group_result;
 
+    // Sequential (by-object) selector plans, keyed by object; see sequential_dynamic_orderings().
+    // Rebuilt (or cleared) on every process().
+    std::map<const PrintObject*, ToolOrdering> m_sequential_dynamic_orderings;
+
     // Used to cache filament parameter information
     FilamentIndexMap m_filament_index_map;
     // Used to cache printer and process parameter information