read the gamepad from dora-joy and publish twist and command

The pad moves to dora-joy, so this node keeps no hardware dependency and the
pad becomes reusable. It arrives on `joy` as a plain reading; `JoyInput.read`
treats silence past JOY_TTL_S as absence, because that node dying looks like
silence rather than like an unplugged pad and the arm cannot tell them apart.

Both control sources are now normalised to a [-1, 1] six-vector before anything
is scaled, and the scaling happens in one function. The web path used to pass a
velocity straight through without going near mapping, which is why the console
had to speak the arm's units. It no longer does.

`twist` (SI) and `command` (robot-agnostic verbs) are the standard ports. `jog`
and `request` still carry the same intent in dora-ulite6's units and service
names so the two repositories can move independently; LEGACY_REQUEST is the
only place that knows what that node calls a verb. Wire one or the other, never
both. `joint_jog` is specified in the manifest and deliberately not built.

Schemas are declared rather than inferred: pyarrow reads a null `value` as its
own type, so an inferred `command` would change its port's type between one
verb and the next.

Three bugs found while moving this code, each with a test:

- `Sample.active` compared raw axes against a threshold, but SDL rests a
  trigger at -1.0, so every connected pad read as in use for ever: the pad took
  the lease on plug-in and GAMEPAD_IDLE_RELEASE_S never fired.
- The e-stop latch was never consulted when deciding a velocity, so Back
  stopped the arm for one tick and the next stick nudge drove it again. Nothing
  on the pad could clear it either. It is now checked above the lease, and X
  releases it and clears the controller's error, as the console's RESET does.
- Buttons were read before the arbiter granted the lease, so the first press
  after the pad had been idle was swallowed: not owned yet when read, and no
  longer a rising edge by the next tick.

tests/test_joy.py

@@ -0,0 +1,61 @@
+"""The pad as it arrives on the wire, and what silence on that wire means."""
+
+import pyarrow as pa
+
+from dora_teleop.joy import ABSENT, JoyInput, Sample, decode
+from tests.conftest import input_event, joy_message, stick
+
+
+def joy_event(sample):
+    return input_event("joy", joy_message(sample))
+
+
+def test_a_reading_survives_the_round_trip():
+    sample = decode(joy_event(stick(axes=[0.5, -0.5], buttons=[False, True])))
+
+    assert sample.axes[:2] == [0.5, -0.5]
+    assert sample.buttons == [False, True]
+    assert sample.present is True
+
+
+def test_an_absent_pad_decodes_as_absent_not_as_centred():
+    sample = decode(joy_event(ABSENT))
+
+    assert sample.present is False
+    assert sample.axes == []
+
+
+def test_a_pad_with_fewer_axes_than_the_layout_decodes_without_complaint():
+    # A three-axis flight stick is a strange thing to drive an arm with, but it
+    # must not take the node down; `mapping.axis` treats a missing one as centred.
+    sample = decode(joy_event(Sample(axes=[0.0, 0.0, 0.0], buttons=[False], present=True)))
+
+    assert len(sample.axes) == 3
+
+
+def test_a_message_with_no_rows_reads_as_absent():
+    empty = input_event("joy", pa.array([], type=joy_message(ABSENT).type))
+
+    assert decode(empty) is ABSENT
+
+
+def test_a_fresh_reading_is_handed_back():
+    joy = JoyInput(ttl_s=0.2)
+    sample = stick(axes=[0.5])
+    joy.accept(sample, 100.0)
+
+    assert joy.read(100.1) is sample
+
+
+def test_a_reading_nobody_is_refreshing_reads_as_absent():
+    # dora-joy publishes every tick, so silence means it died — and a dead pad
+    # node is indistinguishable from an unplugged pad as far as the arm cares.
+    joy = JoyInput(ttl_s=0.2)
+    joy.accept(stick(axes=[0.5]), 100.0)
+
+    assert joy.read(100.5) is ABSENT
+
+
+def test_nothing_ever_arriving_reads_as_absent():
+    # A dataflow with no `joy` wired at all, which is a browser-only console.
+    assert JoyInput(ttl_s=0.2).read(100.0) is ABSENT