fix(puzzle): an object steps once per movement phase; negated conversion is settled per object

Bug 1 (modules 08-10): a YOU object pulled by an earlier mover took a second step of its own. Level movement now keeps the ids that stepped in a committed plan this phase; such a YOU object starts no move, and Planner try_move answers no for it. Regression: test_08x_pulled_you_moves_once (Module 8 Expansion Drop).

Bug 2 (modules 09-10): convert honoured negation only per rule, so ALL IS ROCK beat BABA IS NOT ROCK. A target Y is now skipped for an object if any active negated rule IS NOT Y names it. Module 9 and 10 references (and their drop solutions) now carry ALL, the Module 7 Expansion Drop. Regression: test_09_negated_conversion_beats_group.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>

course/08-push-chains/reference/rust/README.md

@@ -5,8 +5,8 @@ The course's own engine as of the end of Module 8. Part I's card engine is uncha
 - `cards/` (at the crate root; not in this directory): Part I's card data, a copy of `course/cards/` staged by `tools/verify-references.mjs`. Part II doesn't read it.
 - `src/engine/puzzle/`: the Part II engine. It names no noun: the engine's own words are the operators `IS`, `AND`, `NOT`, the meta-noun `TEXT`, the property `PUSH` of the base rule `TEXT IS PUSH`, and from Module 8 the property `YOU`, which picks the objects that move.
   - `grid.rs`: the level format, object kinds and the board. Module 8 adds `Board::find`, `Board::remove`, `Board::shift`, `Board::at` and `Display` for `Kind` (the kind as placed, for `kinds_at`).
-  - `movement.rs` (new): validate, then commit. `Planner` (`try_move`, `staying_at`, `destroy`, `has`), `Step`, `Plan`, `Response` and `Dir`. The planner reads the board and plans one step at a time; for each step it runs content's movement responses in order, and rolls back everything a step added if a response blocks it. The edge of the level blocks every step.
-  - `level.rs`: a level in play. Module 8 adds `Level::move_you`: the `YOU` objects move one at a time, furthest ahead first, each planned and then committed; the rules are reparsed once at the end. `has_property` is `false` for a destroyed object.
+  - `movement.rs` (new): validate, then commit. `Planner` (`try_move`, `staying_at`, `destroy`, `has`), `Step`, `Plan`, `Response` and `Dir`. The planner reads the board and plans one step at a time; for each step it runs content's movement responses in order, and rolls back everything a step added if a response blocks it. The edge of the level blocks every step, and an object that has already stepped in the same move can't step again.
+  - `level.rs`: a level in play. Module 8 adds `Level::move_you`: the `YOU` objects move one at a time, furthest ahead first, each planned and then committed, and an object steps at most once per move (a `YOU` object that an earlier move carried along doesn't start its own); the rules are reparsed once at the end. `has_property` is `false` for a destroyed object.
   - `word.rs`, `parse.rs`, `resolve.rs`: unchanged.
   - `mod.rs`: the module's exports.
 - The rest of `src/engine/`: Part I, unchanged.

course/08-push-chains/reference/rust/src/engine/puzzle/level.rs

@@ -5,6 +5,8 @@
 //! A move (Module 8) is planned for each `YOU` object, then committed; the rules are
 //! reparsed once, after all of them.
 
+use std::collections::BTreeSet;
+
 use super::grid::{Board, Kind, LevelDef, ObjectId};
 use super::movement::{Dir, Plan, Planner, Response};
 use super::parse::{parse, Rule};
@@ -86,6 +88,10 @@ impl Level {
     /// move one at a time, the one furthest ahead in `dir` first (oldest first on a
     /// tie); each one's move is planned in full, then committed, before the next is
     /// planned. Every move uses the rules in force before the first.
+    ///
+    /// An object steps at most once in a movement phase. A `YOU` object that an
+    /// earlier move already carried along (pushed, or moved by any other response)
+    /// doesn't start a move of its own, and no later move can make it step again.
     pub fn move_you(&mut self, dir: Dir) {
         let (dx, dy) = dir.delta();
         let mut you: Vec<_> = self
@@ -95,14 +101,19 @@ impl Level {
             .map(|o| (-(o.x * dx + o.y * dy), o.id))
             .collect();
         you.sort();
+        let mut stepped = BTreeSet::new();
         for (_, id) in you {
             if self.board.find(id).is_none() {
                 continue; // destroyed by an earlier move
             }
-            let mut planner = Planner::new(self, dir);
+            if stepped.contains(&id) {
+                continue; // already moved, by an earlier move
+            }
+            let mut planner = Planner::new(self, dir, &stepped);
             if planner.try_move(id) {
                 let plan = planner.into_plan();
                 self.commit(&plan, dir);
+                stepped.extend(plan.moving.difference(&plan.destroyed));
             }
         }
         self.reparse();

course/08-push-chains/reference/rust/src/engine/puzzle/movement.rs

@@ -59,18 +59,22 @@ pub struct Plan {
     pub destroyed: BTreeSet<ObjectId>,
 }
 
-/// Plans one move on a board it only reads.
+/// Plans one move on a board it only reads. `stepped` holds the objects that have
+/// already stepped in this movement phase, in an earlier committed plan: an object
+/// steps at most once per phase, so none of them can step again.
 pub struct Planner<'a> {
     level: &'a Level,
     dir: Dir,
+    stepped: &'a BTreeSet<ObjectId>,
     plan: Plan,
 }
 
 impl<'a> Planner<'a> {
-    pub fn new(level: &'a Level, dir: Dir) -> Planner<'a> {
+    pub fn new(level: &'a Level, dir: Dir, stepped: &'a BTreeSet<ObjectId>) -> Planner<'a> {
         Planner {
             level,
             dir,
+            stepped,
             plan: Plan::default(),
         }
     }
@@ -100,11 +104,16 @@ impl<'a> Planner<'a> {
     /// Plan object `id` stepping one tile in the move's direction, with whatever
     /// the responses add. Returns whether it can. If it can't, the plan is left as
     /// it was before the call. An object already planned to move, or to be
-    /// destroyed, is out of the way: the answer is yes, and nothing is added.
+    /// destroyed, is out of the way: the answer is yes, and nothing is added. An
+    /// object that has already stepped in this movement phase can't step again: the
+    /// answer is no.
     pub fn try_move(&mut self, id: ObjectId) -> bool {
         if self.plan.moving.contains(&id) || self.plan.destroyed.contains(&id) {
             return true;
         }
+        if self.stepped.contains(&id) {
+            return false;
+        }
         let level = self.level;
         let o = level.board().get(id);
         let (dx, dy) = self.dir.delta();