Make filter_speckle a finish-phase filter, tunable without re-clustering

Speckle removal moves out of the frontends into Segmentation::filter_speckle,
applied in the finish phase. The color frontend now clusters with
good_min_area = 0 and the binary frontend emits every cluster, so the cached
segmentation retains all regions and the speckle threshold can be retuned via
finish() with no re-clustering. Pipeline gains a speckle_area field
(Config sets it from filter_speckle^2).

Frontend structs drop their filter_speckle_area field. Output on clean images
is unchanged (golden/equivalence pass unblessed); noisy images are filtered
downstream instead of during clustering. Adds a test tuning filter_speckle on
one cached segmentation.

Add finish-phase thin-strand filter (restores thread-like rejection)

good_min_area = 0 disabled visioncortex's thread-like rejection (which was
gated on good_min_area > 0). Reintroduce it in our repo as a finish-phase
step: Segmentation::filter_thin drops regions whose perimeter >= area
(average thickness under ~2px), using the same Shape::image_boundary_list
metric so the heuristic matches. It's toggleable on a cached segmentation
(Config::filter_thin, on by default), unlike the clustering-time version.

Exposed via CLI --keep-thin, Python filter_thin, and Node filterThin. Adds
RegionMask::perimeter/is_thin and a reuse test toggling it on one cached
segmentation. Clean-image goldens are unaffected (large regions aren't thin).

README: document binary thresholding, --keep-thin, and finish-phase filters

Add the new CLI flags (--threshold, --adaptive, --adaptive-window,
--adaptive-t, --keep-thin) to the options block and "New in 1.0"; note that
--optimize is encoding-only (precision is --path-precision) and that speckle/
thin filtering run after clustering. Add adaptive-threshold examples for CLI,
Python, and Node.

Return speckle/thin filtering to clustering (fix gum-tree regression)

good_min_area is visioncortex's clustering `deepen` gate, not a speckle
post-filter: it decides whether a small or thread-like patch is absorbed
into its nearest-color neighbour or kept as its own layer, and it enables
the thread-like rejection (perimeter < area). An earlier change set it to 0
to make filter_speckle "retunable downstream", which disabled the thin
check and reshaped the whole hierarchy — dissolving gradient-boundary
structure that clustering is meant to absorb. The Gum Tree preset's central
trunk vanished at gradient-step ~26 where the pre-1.0 path held it to 128.
Clean-logo goldens couldn't exercise it, so it shipped green.

Follow the proven webapp model instead: speckle lives inside clustering
(good_min_area = filter_speckle^2 for the colour frontend; a post-cluster
size gate for the binary frontend). The segment/finish split stays — it is
the progressive model (cluster once, re-run colour/curve/optimize cheaply);
clustering params (speckle, colour precision, layer difference, binary
threshold) re-segment.

Remove the downstream band-aids: Segmentation::filter_speckle/filter_thin,
RegionMask::perimeter/is_thin, the pipeline speckle_area/filter_thin fields,
Config::filter_thin, CLI --keep-thin, Python filter_thin, Node filterThin.
Update the two reuse tests that encoded the wrong contract and the binary
threshold test to use BinaryFrontend::min_area. All goldens, equivalence,
progress, and reuse tests pass.

README.md

@@ -49,9 +49,7 @@ Technical descriptions of the [tracing algorithm](https://www.visioncortex.org/v
 
 ## Desktop App (coming soon)
 
-![screenshot](docs/images/screenshot-01.png)
-
-![screenshot](docs/images/screenshot-02.png)
+![screenshot](docs/images/desktop-app.png)
 
 ## Cmd App
 
@@ -90,6 +88,10 @@ Options:
       --palette-file <PALETTE_FILE>          Fixed palette from a file (hex colors, comma/newline separated)
       --max-colors <MAX_COLORS>              Auto-quantize to at most N colors
       --optimize <OPTIMIZE>                  Output optimization: 0 = off, 1 = quantize+simplify, 2 = + shorthands
+      --threshold <THRESHOLD>                Binary mode: fixed threshold 0..=255 (foreground below it)
+      --adaptive                             Binary mode: Bradley–Roth adaptive threshold (uneven lighting)
+      --adaptive-window <ADAPTIVE_WINDOW>    Adaptive window size in px (0 = auto); implies --adaptive
+      --adaptive-t <ADAPTIVE_T>              Adaptive sensitivity: % below local mean (default 15)
   -h, --help                                 Print help
   -V, --version                              Print version
 ```
@@ -102,7 +104,11 @@ Options:
 - **`--palette` / `--palette-file`** — snap colors to a fixed palette
   (nearest in OKLab); **`--max-colors`** auto-quantizes the palette.
 - **`--optimize`** — output size passes (coordinate quantization, redundant-
-  point removal, relative/shorthand path encoding).
+  point removal, relative/shorthand path encoding). Note: coordinate
+  precision is set separately by `--path-precision`, the bigger size lever.
+- **Binary thresholding** — a tunable fixed cutoff (`--threshold`) or
+  **Bradley–Roth adaptive** thresholding (`--adaptive`, with `--adaptive-window`
+  / `--adaptive-t`) for scans with uneven lighting.
 
 ## Downloads
 
@@ -125,6 +131,9 @@ cargo install vtracer-cli
 # black & white line art
 ./vtracer input.jpg output.svg --preset bw
 
+# scanned/photographed line art with uneven lighting
+./vtracer scan.jpg output.svg --colormode bw --adaptive
+
 # seam-free mosaic (gapless tessellation)
 ./vtracer input.jpg output.svg --hierarchical cutout
 
@@ -160,6 +169,10 @@ cfg = vtracer.Config(mode="polygon", hierarchical="cutout")
 cfg.palette = ["#1b1b1b", "#e0c088", "#5a7d3c"]
 svg = cfg.convert_bytes(data)
 vtracer.Config.poster().convert_file("photo.jpg", "poster.svg")
+
+# binary with adaptive (Bradley–Roth) thresholding
+bw = vtracer.Config(color_mode="bw", adaptive=True)
+svg = bw.convert_file("scan.jpg", "scan.svg")
 ```
 
 See [`crates/vtracer-py`](crates/vtracer-py/README.md) for the full API.
@@ -178,6 +191,9 @@ const vtracer = require('@visioncortex/vtracer');
 await vtracer.convertFile('in.png', 'out.svg', { mode: 'polygon' });
 const svg = vtracer.convertBuffer(buffer, { preset: 'poster' });
 const svg2 = vtracer.convertPixels(rgba, width, height, { colorMode: 'bw' });
+
+// binary with adaptive thresholding
+const bw = vtracer.convertBuffer(buffer, { colorMode: 'bw', adaptive: true });
 ```
 
 ## Citations