feat: module 06 parser

First Part II module. The cumulative reference adds a second engine
(src/engine/puzzle: grid, lexer, parser) beside Part I's; nouns and
properties are data in src/content/words.json, and the engine names only
IS/AND/NOT/TEXT and the base rule TEXT IS PUSH. Rules are recompiled from
the board on every change; rules() is a sorted set. Adds the M6 scenarios
and tests (rows, columns, shared IS, AND distribution, stacked text, base
rule), the HOT word as a data-only Expansion Drop, the lesson with the
Part II bridge, and the Rust LevelDef shape in harness.md.

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

course/06-parser/reference/ts/src/engine/aura.ts

@@ -0,0 +1,42 @@
+// Auras, and the one routine that applies trigger multipliers.
+//
+// An aura is data on a card: a continuous effect its minion has while in play.
+// The engine never asks "is that card on the board?" in the middle of resolving
+// something. It takes a snapshot of the auras in force at defined points (an Aura
+// Update) and every rule reads the snapshot.
+//
+// Hearthstone runs two kinds of Aura Update when the outermost Phase ends: one for
+// Health/Attack auras before the Death Creation Step, and one for every other aura
+// after it. Trigger multipliers are "Other" auras, so a minion that dies in a Death
+// Creation Step no longer multiplies the Deathrattles of that step's Death Phase.
+// Summoning a minion also runs an Aura Update.
+
+import type { TriggerOn } from "./card";
+import type { PlayerId, World } from "./world";
+
+/** Aura Update (Other): replace the snapshot with the auras of every minion now in play. */
+export function auraUpdateOther(world: World): void {
+  world.setActiveAuras(
+    world.minionsInPlay().flatMap((id) =>
+      world.card(world.cardName(id)).auras.map((aura) => ({ owner: world.ownerOf(id), aura })),
+    ),
+  );
+}
+
+/**
+ * How many times a trigger listening for `on`, on a minion `owner` controls, activates
+ * when it resolves. Reads the snapshot from the last Aura Update. With no multiplier in
+ * force the answer is 1. Multipliers with `stacking: "max"` contribute their largest
+ * `times`; each `"additive"` one adds `times - 1` extra activations.
+ */
+export function activations(world: World, owner: PlayerId, on: TriggerOn): number {
+  let max = 1;
+  let extra = 0;
+  for (const active of world.activeAuras()) {
+    const { trigger, times, stacking } = active.aura;
+    if (active.owner !== owner || trigger !== on) continue;
+    if (stacking === "max") max = Math.max(max, times);
+    else extra += times - 1;
+  }
+  return max + extra;
+}