feat: undo in Module 9 and stackAt from Module 8; Lesson 8 quote matches the reference

Baba.undo() restores the level before the last step or move (board snapshot:
objects in age order with ids, the id counter, and won; rules recompiled).
place clears the history. SpellGrid's undo throws/panics 'not supported'.
stackAt / stack_at lists a tile's kinds oldest first, on Baba and SpellGrid.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

course/10-spellgrid/reference/rust/src/engine/puzzle/level.rs

@@ -8,10 +8,15 @@
 //! A turn (Module 9) runs the phases of `TURN` in order: movement, parse,
 //! conversion, parse, content's hazards, the win check, parse.
 //!
+//! Undo (Module 9): before each move or turn the level saves the board (every
+//! object's id, kind and position, oldest first, and the id counter) and `won`.
+//! The rules are not saved: undo restores the board and reparses.
+//!
 //! Module 10: what happens to the objects a turn destroys is a destroy function the
 //! caller may pass in (`step_with`, `move_you_with`). The default, `remove_all`,
 //! removes them. SpellGrid passes one that sends minions to Part I's Death Creation
-//! Step instead.
+//! Step instead. SpellGrid doesn't offer undo: Part I has state the level's
+//! snapshot doesn't cover.
 
 use std::collections::BTreeSet;
 
@@ -31,6 +36,16 @@ pub struct Level {
     rules: Vec<Rule>,
     active: Vec<Rule>,
     won: bool,
+    /// What `undo` puts back: one entry per move or turn, the latest last (Module 9).
+    history: Vec<Snapshot>,
+}
+
+/// The level before a move or a turn: the whole board (its objects, oldest first,
+/// and its id counter) and `won`.
+#[derive(Debug, Clone)]
+struct Snapshot {
+    board: Board,
+    won: bool,
 }
 
 /// The property that makes an object move when the player moves.
@@ -69,6 +84,7 @@ impl Level {
             rules: vec![],
             active: vec![],
             won: false,
+            history: vec![],
         };
         for o in &def.objects {
             level.board.place(Kind::parse(&o.kind), o.x, o.y);
@@ -79,6 +95,7 @@ impl Level {
 
     pub fn place(&mut self, kind: &str, x: i32, y: i32) -> ObjectId {
         let id = self.board.place(Kind::parse(kind), x, y);
+        self.history.clear();
         self.reparse();
         id
     }
@@ -154,6 +171,7 @@ impl Level {
 
     /// `move_you`, with destroyed objects going to `destroy` (Module 10).
     pub fn move_you_with(&mut self, dir: Dir, destroy: &mut Destroy) {
+        self.save();
         self.movement(dir, destroy);
         self.reparse();
     }
@@ -165,6 +183,7 @@ impl Level {
 
     /// `step`, with destroyed objects going to `destroy` (Module 10).
     pub fn step_with(&mut self, dir: Dir, destroy: &mut Destroy) {
+        self.save();
         for phase in TURN {
             match phase {
                 Phase::Movement => self.movement(dir, destroy),
@@ -176,6 +195,26 @@ impl Level {
         }
     }
 
+    /// Put the level back as it was before the last move or turn (Module 9), and
+    /// reparse. False, and no change, if there is none; `place` forgets them all.
+    pub fn undo(&mut self) -> bool {
+        let Some(last) = self.history.pop() else {
+            return false;
+        };
+        self.board = last.board;
+        self.won = last.won;
+        self.reparse();
+        true
+    }
+
+    fn save(&mut self) {
+        let snapshot = Snapshot {
+            board: self.board.clone(),
+            won: self.won,
+        };
+        self.history.push(snapshot);
+    }
+
     /// The `YOU` objects 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

course/10-spellgrid/reference/rust/src/harness.rs

@@ -317,6 +317,12 @@ impl Baba {
         kinds
     }
 
+    /// The kinds on tile (x, y), as `kinds_at`, but oldest object first.
+    pub fn stack_at(&self, x: i32, y: i32) -> Vec<String> {
+        let board = self.level.board();
+        board.at(x, y).map(|o| o.kind.to_string()).collect()
+    }
+
     // ---- Module 9 ----
 
     /// Play one whole turn: movement, parse, conversion, parse, hazards, win
@@ -334,6 +340,12 @@ impl Baba {
     pub fn lost(&self) -> bool {
         self.level.lost()
     }
+
+    /// Put the level back as it was before the last `step` or `move_dir`. False, and
+    /// no change, if there is none; repeated calls walk further back.
+    pub fn undo(&mut self) -> bool {
+        self.level.undo()
+    }
 }
 
 fn normalised(rules: &[puzzle::Rule]) -> Vec<String> {
@@ -402,6 +414,10 @@ impl SpellGrid {
         kinds.sort();
         kinds
     }
+    pub fn stack_at(&self, x: i32, y: i32) -> Vec<String> {
+        let board = self.grid.level().board();
+        board.at(x, y).map(|o| o.kind.to_string()).collect()
+    }
     pub fn step(&mut self, dir: Dir) {
         self.grid.step(dir);
     }
@@ -411,6 +427,11 @@ impl SpellGrid {
     pub fn lost(&self) -> bool {
         self.grid.level().lost()
     }
+    /// Not supported: Part I has state (health, hands, the log) that the level's
+    /// snapshot doesn't cover. Panics.
+    pub fn undo(&mut self) -> bool {
+        panic!("undo is not supported in SpellGrid");
+    }
 
     // ---- Module 10 ----