Discover/connect an instrument and attach it to the session.

Runs the transport cascade (USB → LAN → manual host). In Part 1 the backend
factory yields a ``MockInstrument``, so this succeeds with zero hardware.

Return the connected instrument's parsed identity.

Report detected capabilities (channels, bandwidth, options).

Capture the on-screen waveform for one channel.

Capture the deep-memory waveform for one channel.

Capture multiple channels on the same time base, aligned.

The instrument shares one time base across channels, so a sequence of reads is already time-aligned. (Real hardware reads them back-to-back; the mock is instantaneous.)

Take a single measurement of one quantity on one channel.

Take a snapshot of several measurements at once for one channel.

Poll one measurement repeatedly, returning a short time series.

``interval_s`` is honored via the instrument's settle hook so the mock stays
instant in tests while real hardware actually waits between reads.

Set vertical config for a channel (enable, V/div, offset, coupling).

Set horizontal time base (s/div and offset).

Configure the edge trigger (source channel, level, slope).

Start continuous acquisition (disruptive).

Stop acquisition (disruptive).

Arm a single acquisition (disruptive).

Force a trigger event (disruptive).

Set acquisition type and/or memory depth (disruptive).

Characterize the signal on channel (FLAGSHIP — stubbed in Part 1).

Validates the channel against the connected instrument so the scaffold is
exercised end-to-end, then returns a structured not-implemented result that
names the stages and the settle-and-verify contract. The real loop is wired
in Part 3 once the library's MEASure/ACQuire/TRIGger subsystems exist.