Stream and motion robustness: harness rules, catalog tests, the hand-back's counter scale

The GRBL driver's stream engine and its motion envelope change
(grblHAL-glowforge: the shipper writes outside the lock, a clamp inside
an armed window faults, the X/Y soft limits follow the home, the
machine's settings are pinned, the homing keys are clamped). This commit
carries the host rules and the catalog tests that hold them; the driver
commit follows, because its CI fetches these harnesses unpinned.

scripts/bench/laser_stream_test.py:
- Rule 28: a 300 ms producer stall while armed faults the stream with
  ALARM:17, the kernel sees no step burst (at most the planned steps per
  100 ticks), the stream ends dark, the latch sideband ends on the lock.
  The same stall unarmed is a warning: the move completes with every
  step, the clamp visible as the burst the kernel counts.
- Rule 29: a 300 ms stall of the sink's write leaves the producer on
  pace: no clamp, every step, lit through, dark at the end.
- The stand-in engine takes GFSINK_STALL_MS and GFSINK_WRITE_STALL_MS,
  null-sink only.

scripts/bench/z_envelope_test.py:
- Rule 10: homed (a gfcloud home), a program move past X max, Y max or
  the near edge alarms with ALARM:2 before any motion, a jog past the bed
  is refused with error 15, a move inside the bed runs, and a $20 write
  keeps the limits. The core repeats the last error for the line after a
  refused jog until an empty line clears it, so the rule sends one.

forgetest/forgetest/suite/motion.py:
- motion.soft-limits (kind auto, no emission): homes through the cloud
  suite's gfhome homing when the machine is not homed, then the three
  refusals (ALARM:2, the kernel counters still), the refused jog, the
  inside move, and the return to the corner read at rest.
- motion.deadman phase 2b: a 100 ms SIGSTOP mid-move, inside the
  kernel's queue: no underrun, the controller's log warns of the clamped
  late events, the move completes with every step (read at rest), the
  latch stays locked. The armed clamp is proven on the host (rule 28).

forgetest/forgetest/suite/cloud.py:
- gfhome_homing drains the driver's answer to $H once the session ends:
  it sits behind the status reports and passed for the reply to the
  caller's next command (a setting read as None).

forgetest/forgetest/baseline.py:
- The hand-back reads the position counters at the kernel's own
  microstep mode (cnc/x_mode, read before the sysfs restore puts the
  settings' mode back). At the x8 constant, an x32 machine's 30 mm read
  as 120 mm, beyond the return bound, and the displaced head was left in
  place. The dead band scales the same way. tests/test_baseline.py holds
  both.

Proof. Host: stream rules 1 to 29 and z_envelope rules 1 to 10 against
the null-sink driver, the forgetest unit tests. Bench reference:
motion.soft-limits passed (X 495 and Y 279 refused with ALARM:2 and
0.000 mm of kernel motion, X-1 the same, the jog error:15, the inside
move ran, back at the corner 0.0/0.0 mm); motion.deadman passed with
the new phase (92 late events clamped, max behind 92.3 ms, no underrun,
30.0 mm counted, latch locked) and the hand-back jogged the head back
under the x32 scale.

scripts/bench/z_envelope_test.py

@@ -38,6 +38,17 @@ settings and places the edge on its step grid:
      wider window runs to its ends, two half-steps past either alarms
   9. a stop count out of range (41) falls back on its side alone
 
+The X and Y soft limits are the driver's as well: off while the
+position is not trusted (the core's $20 cannot be turned on with $22
+off), on after a home, when the envelope is the bed. A scripted home
+(homing_mode = gfcloud with a runner that exits 0, the host hook) sets
+them:
+
+ 10. after the home a program move past X or Y max raises ALARM:2
+     before any motion, a jog past it is refused with error 15, and a
+     move inside the bed runs; a stream fault or a controller start
+     drops them again with the reference
+
 The binary keeps its settings in EEPROM.DAT in the working directory, so
 each run starts from defaults in a temporary directory and leaves
 nothing behind.
@@ -255,6 +266,51 @@ def referenced_cases():
         s.close()
 
 
+def homed_cases():
+    """After a scripted gfcloud home the bed is the X/Y envelope."""
+    conf = {"lens_hall_edge_z_mm": "3.35", "homing_mode": "gfcloud", "gfcloud_home_cmd": "true"}
+    s = Session(conf=conf, referenced=True)
+    try:
+        free_in_xy(s, "before the home")
+        x_travel = float(s.setting("$130"))
+        y_travel = float(s.setting("$131"))
+        reply = s.send("$H", 5.0)
+        if "ok" not in reply:
+            fail("the scripted home was refused: %r" % reply)
+        s.wait_idle()
+        st = s.send("?")
+        m = re.search(r"MPos:(-?[\d.]+),(-?[\d.]+)", st)
+        check(m and abs(float(m.group(1))) < 0.01 and abs(float(m.group(2))) < 0.01,
+              "homed: X and Y sit at the origin", "homed: X/Y are not at the origin: %r" % st)
+        check(s.move("G90 G0 X%.1f" % (x_travel + 5)), "homed: X past the bed alarms",
+              "homed: a move past X max ran")
+        s.wait_idle()
+        check(s.move("G90 G0 Y%.1f" % (y_travel + 5)), "homed: Y past the bed alarms",
+              "homed: a move past Y max ran")
+        s.wait_idle()
+        check(s.move("G90 G0 X-1"), "homed: X past the near edge alarms",
+              "homed: a move past X min ran")
+        s.wait_idle()
+        reply = s.send("$J=G91X%.1fF1200" % (x_travel + 5), 1.5)
+        check("error:15" in reply, "homed: a jog past the bed is refused with error 15",
+              "homed: a jog past the bed was not refused with error 15: %r" % reply)
+        # The core answers the line after an error with that error again
+        # until an empty line (or a $ command) clears it: the sender's
+        # acknowledgment at compatibility level 0.
+        s.send("", 1.0)
+        check(not s.move("G90 G0 X10 Y10"), "homed: a move inside the bed runs",
+              "homed: a move inside the bed was blocked")
+        s.wait_idle()
+        # A settings write does not drop them: the driver re-applies the
+        # mask after the core clears it.
+        s.write_setting("$20=0")
+        check(s.move("G90 G0 X%.1f" % (x_travel + 5)), "homed: X past the bed still alarms after a $20 write",
+              "homed: a $20 write freed X")
+        s.wait_idle()
+    finally:
+        s.close()
+
+
 def main():
     if not os.path.isfile(BIN):
         fail("no controller binary at %s" % BIN)
@@ -285,6 +341,7 @@ def main():
     finally:
         s.close()
     referenced_cases()
+    homed_cases()
     print("PASS z_envelope_test")