docs(series4): CORRECTED -- cellular cost is NOT independent of payload

I had it as "~0.65 s per round trip, independent of payload size", and based
design advice on it ("minimise round trips, not bytes").  The first claim is
wrong and the second is too strong.

Every measurement behind it had a SMALL payload -- 59 B status, 266 B setup
records, 1024 B download chunks.  With the byte term small and similar across all
of them, per-command cost looked constant.  It was a narrow-range fit
extrapolated past its evidence.

Measured against a 14,176 B single response on UM12947 over an RX55:

  1,024 B   0.67 s      8,192 B   3.59 s
  2,048 B   1.22 s     14,176 B   6.25 s
  4,096 B   2.13 s

  t ~ 0.21 s + bytes / 2,350   -- fits within +/-11% over a 14x size range

The old 0.65 s figure was right FOR A 1 KB RESPONSE and is that model evaluated
at 1 KB.  Round trips still cost (0.21 s each; 24 of them for a setup walk is
still 16 s), but bytes cost more than round trips on anything over ~500 B, and
that reverses the advice: for STATUS work minimise commands, for DOWNLOADS the
floor is throughput and batching does not beat it.

So the 16 KB chunk size is a ~30% win, not 14x.  UM20147's 72,560-byte event is
~46 s at THOR's 1024 B and ~32 s at 16,384 B, because ~31 s of it is bytes on the
wire.  Still worth keeping -- 30% faster, and 14x fewer requests is 14x fewer
chances for a link to drop mid-download -- but the earlier "~3.2 s" projection
was wrong and is withdrawn.

Corrected in all four places it had propagated: the protocol reference, the
CHUNK_SIZE comment, the probe's verdict, and mm_client_check's banner.  The probe
now also prints a net time per measurement, since its raw timings include the
idle gap while the control reads to frame completion -- comparing them directly
was misleading.

Also confirmed in the same run: 16 KB-class responses survive a cellular PAD.
1,024 / 2,048 / 4,096 / 8,192 / 14,176 B all arrived in one frame, byte-identical,
over an RX55.  14,176 B is UM12947's largest event so the ceiling itself was not
reached, but a 14 KB response crossing the PAD intact is what needed proving.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ru8Lg9HkkYvX9VWWo65SmL

micromate/protocol.py

@@ -113,9 +113,14 @@ EVENT_TOKEN = 0xFE
 # known-good download, and anything larger is **silently clamped to 16,384** —
 # correct bytes, short length, no error.
 #
-# This matters because round trips dominate a cellular download at ~0.65 s each
-# regardless of payload.  A 72,560-byte event is 71 requests (~46 s) at THOR's
-# size and **5 requests (~3.2 s)** at this one.
+# ⚠ The win is real but MODEST, and smaller than a first reading suggests.
+# Measured over an RX55, cost per request is ~0.21 s + bytes/2350 — so a download
+# is throughput-bound, not round-trip bound.  A 72,560-byte event costs ~46 s at
+# THOR's 1024 B and ~32 s at 16,384 B: a **30% saving**, not 14x, because ~31 s of
+# it is bytes on the wire and no amount of batching addresses that.
+#
+# Still worth having: 30% faster, and 14x fewer requests is 14x fewer chances for
+# a link to drop mid-download.
 #
 # ⚠ Measured on ONE unit, over USB.  The loop below is driven by bytes received
 # rather than chunk index, so a unit that clamps lower simply takes more