Replaces wall-clock timeouts with progress-based polling so slow CI
runners do not spuriously fail, adds deterministic teardown (try/finally
with ordered shutdown and reverse-order reference drops) to avoid C++
use-after-free on worker exit, and closes a reorder-drain race by
waiting until every generated frame has reached the reorder stage
before flushing its cache.

- Track server_started/client_started separately so a partial RSSI
  start (server up, client _start raises) still tears down the running
  endpoint in finally instead of leaking it into later tests.
- Assert prbs_rx.getRxCount() == FRAME_COUNT after the drain wait.
  wait_for_progress returns on >=, so without this an unexpected
  duplicated/replayed frame would slip through as long as PRBS errors
  were zero.

wait_for_progress and the RSSI open-deadline loop tracked elapsed time
with time.time(), which is wall-clock and subject to NTP jumps. A
backward step could extend the stall window arbitrarily; a forward step
could trigger a spurious stall failure or premature RSSI timeout.
Switch both sites to time.monotonic().

out_of_order counts RSSI transport segments, not PRBS application frames.
On a standard-MTU link a 2048-byte frame splits into multiple segments, so
out_of_order.cnt >= FRAME_COUNT would return before every generated frame
was observed, reintroducing the reorder-drain race. Compute the expected
segment count from the UDP max payload and packetizer head/tail overhead
and wait on that instead.

out_of_order.cnt counts every outbound RSSI transport segment, including
SYN/ACK handshake and NULL keepalive control frames. The reorder-settle
wait used an absolute target derived only from data segments, so the
prior control-frame count could let it return early and reintroduce the
flush race the wait was added to close. Snapshot cnt immediately before
generating frames and wait for baseline + expected_segments instead.