Dual-shepherd axis-split (HERDING_NDOGS=2)

The launcher can now spawn two `ShepherdDog` robots, each masked to a
single axis of motion, so the herding workload is split orthogonally.

Mechanic:
* `HERDING_NDOGS=2` (default 1) tells `tools/run_webots.sh` to replace
  the single-dog node in the generated test world with two copies:
  - `ShepherdDogX` at (-4, -10), `customData "axis=x"`
  - `ShepherdDogY` at (+4, -10), `customData "axis=y"`
  Each spawn position sits south of the field interior so the pair
  doesn't collide with starting sheep.
* `controllers/shepherd_dog/shepherd_dog.py` reads `getCustomData()`
  at startup; when `axis=x|y` it zeroes the off-axis component of every
  action *after* speed modulation and *before* EMA smoothing. With
  `customData` empty the controller behaves identically to single-dog
  mode, so all existing launches are unaffected.
* The dog's emitter line now carries the robot's name
  (`dog:ShepherdDogX:x:y`), and `controllers/sheep/sheep.py` keeps a
  `dogs` dict keyed by name, picking the closest one each step for
  its flee target. Single-dog runs still use the legacy two-field
  `dog:x:y` format thanks to a length check.
* `HERDING_NDOGS` is written into `herding_runtime.cfg` and exported
  to subprocesses so future tooling can read it.

Verified behaviour in Webots smoke tests (HERDING_NDOGS=2, strombom,
diff/field, 5 sheep): both dogs spawn with the expected names and
axis tags, the dual-dog status print appears, each dog acts only on
its assigned axis early in the trial, and the masking is internally
consistent. The pair stalls before penning under pure axis-split
because each dog reaches its drive standoff and then has only one
degree of freedom — useful research finding for the write-up;
coordination strategy (shared CoM, role-switching, etc.) is future
work.

126 pytest cases still pass.

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

controllers/shepherd_dog/shepherd_dog.py

@@ -267,6 +267,22 @@ def drive_mecanum(vx: float, vy: float, omega: float,
 robot = Robot()
 timestep = int(robot.getBasicTimeStep())
 
+# Multi-shepherd axis split. When the launcher creates two dog instances
+# it sets each robot's customData to "axis=x" or "axis=y"; the controller
+# then masks the off-axis component of every action so the two dogs
+# share the herding workload along orthogonal axes (one closes flank
+# distance in x, the other in y). customData empty = single-dog mode.
+_AXIS_TAG = (robot.getCustomData() or "").strip().lower()
+if _AXIS_TAG.startswith("axis="):
+    DOG_AXIS = _AXIS_TAG[5:]
+    if DOG_AXIS not in ("x", "y"):
+        print(f"[dog] unknown axis={DOG_AXIS!r} in customData; ignoring.")
+        DOG_AXIS = None
+else:
+    DOG_AXIS = None
+DOG_NAME = robot.getName()
+print(f"[dog] name={DOG_NAME}  axis={DOG_AXIS}")
+
 if DRIVE_MODE == "mecanum":
     fl_motor = robot.getDevice("front left wheel motor")
     fr_motor = robot.getDevice("front right wheel motor")
@@ -467,6 +483,13 @@ while robot.step(timestep) != -1:
     # Near-sheep speed modulation (shared by every mode).
     vx, vy = modulate_speed(vx, vy, dog_xy, sheep_positions)
 
+    # Axis-split mask for the dual-dog setup: this dog only commits to
+    # its assigned axis (x or y) so its partner covers the other.
+    if DOG_AXIS == "x":
+        vy = 0.0
+    elif DOG_AXIS == "y":
+        vx = 0.0
+
     # EMA smoothing — kills frame-to-frame action jitter.
     if DRIVE_MODE == "mecanum":
         vx = ACTION_SMOOTH * prev_action[0] + (1.0 - ACTION_SMOOTH) * vx
@@ -485,7 +508,7 @@ while robot.step(timestep) != -1:
                       compass, MOTOR_MAX)
     else:
         drive_diff(vx, vy, left_motor, right_motor, compass, MOTOR_MAX)
-    emitter.send(f"dog:{dog_xy[0]:.4f}:{dog_xy[1]:.4f}")
+    emitter.send(f"dog:{DOG_NAME}:{dog_xy[0]:.4f}:{dog_xy[1]:.4f}")
 
     # Cosmetic ear wiggle.
     ear_phase += 0.12