Carry domain types to the local/remote border, and serialize only there

[vertix]

The harness serializes every observation channel before anything reads it, so what a device produced —
a roboarm.State — reaches the policy stack as flat suffixed strings. Meaning then has to be recovered
from names.

Where this stands

Harness._build_obs calls each channel's serializer and flattens the result:

value = obs.serializer(value)
inputs.update({full: v for full, v in expand_suffixed(name, value) if v is not None})

So an arm's status arrives as the entry robot_state.status (or robot_state.{side}.status on a
bimanual rig), and StopOnFault — which runs in-process, on the rig, with the object right there —
finds it by matching that name:

def _is_robot_status(name: str) -> bool:
    return name.startswith(f'{keys.ROBOT_STATE}.') and name.endswith('.status')

Consequences:

• A rig-side wrapper reads a string convention where it could read a type. The convention is spelled in
  more than one place and nothing checks the two agree.
• The suffixes a serializer emits (.q, .status) and the canonical names in positronic/keys.py are
  the same contract written twice.
• Everything downstream pays the flattening cost even when no wire is involved: an in-process pipeline
  serializes and never deserializes.

Decision

The harness passes domain objects. Serialization happens at the local/remote border and in the dataset
writer, and nowhere else. A wrapper that needs the arm's status reads it off the value with isinstance,
not off a name.

Consequences

• eval.Observation loses its serializer: the value's domain type owns its policy- and dataset-side
  encoding. (The class already carries a TODO saying so.)
• _is_robot_status in positronic/policy/wrappers.py goes, and StopOnFault reads State.status.
• The offboard client serializes on the way out; a server-side stack keeps reading names, since the wire
  carries no types.
• keys.ROBOT_STATUS and friends stay: they name recorded signals and wire entries, which is what they
  are for.

Relation to other work

Falls out of #637, which put the arm's status on the wire as data and left the name-matching behind.

[vertix]

What blocks serializing only at the border

Three rig-side consumers sit outside the local/remote border and need flat, plain data. Two of them
are real blockers.

TemporalStack addresses entries by name. It is configured with
('image.wrist', 'image.exterior', 'robot_state.ee_pose', 'grip') (positronic/cfg/wrappers.py) and has to
sit outside ChunkedSchedule so it sees every control tick. A roboarm.State gives it nothing to stack.

Deployed servers declare the stack the rig runs. Six shipped pipelines put
StopOnFault() | [TemporalStack] | ChunkedSchedule() | RestrictImageSize(...) in the local half, and the rig
builds what the handshake declares. Serialization can move inward by one step at most — to just after
StopOnFault — and only as a new wire-deliverable component every pipeline declares. A server that omits it
hands a State to the codec.

Camera frames reach the stack as shared-memory adapters. RestrictImageSize._restrict recognizes only
np.ndarray, and a frame is a pimm.shared_memory.NumpySMAdapter until Serializers.camera_images unwraps
it. _InferenceWorker._owned copies ndarrays so a producer cannot overwrite a buffer while inference runs;
an adapter passes through uncopied. Tractable — the harness owns the value and can materialise it there —
but it is work the decision does not account for.

The status already arrives as a type

Serializers.robot_state puts the RobotStatus member itself into the observation; it becomes an integer
only on the msgpack wire and in parquet. So StopOnFault can drop _is_robot_status without moving
serialization at all:

def _arms_sound(obs) -> bool:
    return all(is_sound(v) for v in obs.values() if isinstance(v, RobotStatus))

A StopOnFault placed server-side then finds no status. This issue already accepts that ("a server-side
stack keeps reading names, since the wire carries no types"), and no shipped pipeline places it there.

Where this leaves the issue

Open, blocked on TemporalStack's name-addressed keys and on the stack deployed servers declare.

A smaller shape closes most of the Consequences list without touching the wire: give the value's type its
serialization, so eval.Observation loses its serializer field and the dataset writer dispatches on the
type; derive the .q/.dq/.ee_pose suffixes from positronic/keys.py; and use the isinstance check
above.