Multipatch: validate fine block before modulo, raw-core GPU checks, README usage

FixedPatchSet2D.fine_layout rejects non-positive, float, bool or wrong-length
block sizes with ValueError before any modulo (was ZeroDivisionError/TypeError).
The face gap-4 GPU test now checks raw owner cores directly by kind/covered
for every patch (ACTIVE finite, OUTER/holes/covered NaN; INNER not asserted),
not only the masked download and reversed-order parity. README documents the
body-free multipatch call, scope and level-wide fine shape.

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

README.md

@@ -123,7 +123,7 @@ with CudaContext(0) as ctx, FixedPatchStepper(cfg, (8, 6, 24, 18), context=ctx,
 ```
 
 Scope and limits:
-- D2Q9, SRT, FP32, double buffer, unshifted, no LES or forcing; one fixed 2:1 patch.
+- D2Q9, SRT, FP32, double buffer, unshifted, no LES or forcing; fixed 2:1 patch(es), two levels.
 - `coarse_boundary="periodic"` (default) or `"slot_reservoir"` (bottom slot, top
   reservoir; patch needs `y0 >= 4`, `y1 <= ny-4`). Periodic mode ignores the wall/slot config fields.
 - Object centers/radii use the coarse **cell-edge** frame (cell `I` spans `[I, I+1)`),
@@ -135,8 +135,26 @@ Scope and limits:
   divide the WHOLE fine allocation, i.e. `2*(y1-y0)+8` by `2*(x1-x0)+8` including the
   four-cell ghost band. It gives results identical to dense storage and is
   infrastructure for future block AMR, not a speedup.
+- Several separated patches (body-free): pass a sequence of `(x0, y0, x1, y1)`
+  rectangles as `bounds`, at least 4 coarse cells apart, with both `fine_block`
+  and `base_block`. The fine level is then one level-wide grid `(2*ny, 2*nx)`:
+  `run.patch.fine_shape` gives it, `initialize`/`download` use it, and only the
+  patch windows (active region plus 4-cell ghost band, origin `(2*y0-4, 2*x0-4)`)
+  are stored; each window must align with `fine_block`. Order of rectangles does
+  not matter. No bodies/Jets, wall-touching patches or nesting yet.
+
+  ```python
+  cfg = LBMConfig(nx=32, ny=16, viscosity=.1)
+  with CudaContext(0) as ctx, FixedPatchStepper(
+          cfg, ((4, 4, 12, 12), (16, 4, 24, 12)), context=ctx,
+          fine_block=(4, 4), base_block=(4, 4)) as run:
+      run.initialize(np.broadcast_to(rest, (9, *run.patch.coarse_shape)),
+                     np.broadcast_to(rest, (9, *run.patch.fine_shape)))  # (9, 32, 64)
+      run.step(32)
+      coarse_g, fine_g = run.download()  # NaN outside every patch's active cells
+  ```
 - Not available: per-link surface exchange/force readout in blocked mode,
-  checkpoints, moving bodies, multiple patches or dynamic refinement, `Simulation`
+  checkpoints, moving bodies, bodies/Jets with several patches, dynamic refinement, `Simulation`
   integration. Validation so far is storage/operator equivalence and short runs,
   not accuracy, convergence or long-time stability.