Fix shifted pictures: non-blocking Nano drawing, frame check, refresh settings

The Nano's periodic full redraw blocked for ~0.8 s. A frame that arrived
meanwhile overflowed its 64-byte serial buffer; lost bytes in a bitmap
shift the rest of the image (picture moved up), and diff frames never
repaired it.

- Nano: all drawing (frames, effects, the dot refresh) runs from update()
  in ~1 ms slices; the refresh pauses while a frame is received or shown
- New commands: C (reply with the image checksum) and I (refresh minutes,
  EEPROM)
- ESP32: NanoMonitor asks for the checksum after frames and sends the whole
  image again on a mismatch, missing answer or Nano restart; counts ERR
  replies. Periodic whole-image resync.
- Settings: "Dot refresh" and "Image resync" intervals (settings v5,
  v4 records are migrated)
- System tab: loop timing, free memory, frame check counts
- test_driver: the real driver against a simulated panel

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

src/nano/README.md

@@ -46,11 +46,13 @@ Arduino core, EEPROM and the display driver are replaced by fakes in
   being read; while a new frame is being drawn into the buffer the effect pauses, and the
   next `D` starts it again. The orders come from `DotSequence` in
   [lib/BROSE9323/dot_sequence.h](../../lib/BROSE9323/dot_sequence.h).
-- **Every 2 minutes** (`REFRESH_TIME`) it does a full redraw to fix dots that got stuck.
-  A full redraw blocks for about half a second, which is long enough to overflow the
-  64-byte serial buffer. So it only runs right after a `D` (the end of a frame, when the
-  ESP is quiet) or when no serial data has arrived for 2 seconds, and never while an
-  effect runs. It is always instant, with one pulse per dot.
+- **Nothing blocks.** Every frame (also instant ones, `D1`) is flipped from `update()` in
+  slices of about 1 ms, so `loop()` keeps reading the serial port. A blocking redraw used
+  to overflow the 64-byte receive buffer; the lost bytes shifted the rest of a bitmap
+  (the picture moved up and left) and nothing repaired it.
+- **Every 2 minutes** (`I` command, stored in EEPROM, 0 = never) it flips every dot once
+  more, with one pulse, to fix dots that got stuck. This also runs in slices, only while
+  no frame is being received or shown, and continues where it was after a frame.
 - **Flip pulse length** (µs, 50–2000) is set with the `T` command and stored in EEPROM,
   so it is kept after a reboot. The default is 200 µs. `G`, `N` and `E` are stored the
   same way (addresses in `settings.cpp`; values that were never written fall back to the
@@ -78,19 +80,24 @@ skipped and the next line starts clean. Coordinates are 2-digit **hex**. Color i
 | `s` | `sXXYYc` | Set pixel in the buffer |
 | `S` | `SXXYYc` | Set pixel and flip it right away (direct mode) |
 | `F` | `Fc` | Fill the whole buffer |
-| `D` | `D` or `D1` | Push the buffer to the display (changed dots only). `D1`: a frame of moving content (scrolling text, seconds), shown without the refresh effect; the periodic full redraw then waits until the serial line is idle. |
+| `D` | `D` or `D1` | Push the buffer to the display (changed dots only). `D1`: a frame of moving content (scrolling text, seconds), shown without the refresh effect. |
 | `P` | `PXXYYcsTEXT` | Print text at (XX,YY), color `c`, size `s`. A literal `\n` (backslash, n) in TEXT starts a new line. The whole line can be at most 64 characters. |
 | `B` | `BXXYYWWHHcHEX...` | Draw a bitmap. WW must be a multiple of 4. Pixel data is one hex digit per 4 pixels, row by row. The data is drawn while it arrives, so it is not limited to 64 characters. |
 | `R` | `R` | Print the buffer as ASCII art on the serial port |
 | `T` | `Tnnn` | Set the flip pulse length in µs (decimal, 50–2000), stored in EEPROM |
 | `G` | `Gnnn` | Pause after each pulse in µs (decimal, 0–5000), stored in EEPROM |
 | `N` | `Nn` | Pulses for each changed dot (1–3), stored in EEPROM |
+| `I` | `Innn` | Minutes between full redraws (decimal, 0–1440, 0 = never), stored in EEPROM |
+| `C` | `C` | Reply `C xxxx`: checksum of the image received so far (CRC-16/CCITT of the buffer, only the dots, `lib/BROSE9323/buffer_crc.h`), 4 hex digits |
 | `E` | `Ee,nnnn[,f]` | Refresh effect `e` (0 instant, 1 sparkle, 2 wipe, 3 rain, 4 from the middle out, 5 diagonal, 6 spiral, 7 flip all then reveal, 8 push, 9 random), its time in ms (100–10000) and flags `f` (1 = only small changes, default 0), stored in EEPROM |
 
 Replies on the Nano's TX pin:
 
-- `READY` after booting. The ESP waits for it before sending the first frame.
-- `ERR: ...` for invalid commands.
+- `READY` after booting. The ESP waits for it before sending the first frame. Later
+  (while it is on) it means the Nano restarted, e.g. after a power dip.
+- `C xxxx` for `C`. The ESP sends `C` after frames (at most every 3 s) and compares the
+  answer with its own copy; a wrong or missing answer makes it send the whole image again.
+- `ERR: ...` for invalid commands. The ESP counts them (web UI, System).
 
 Example (what the ESP32 sends for one pixel and a refresh):