fix(workbench): LER was Blossom's, reported under every decoder's name

_ler() accepted `kind` and ignored it. The body built
pymatching_compat.Matching.from_detector_error_model(sdem) and decoded with
that, and Matching is hard-wired to BlossomDecoder -- its __init__ declares
`self._decoder: BlossomDecoder` and from_detector_error_model takes no decoder
argument. Every row therefore carried Blossom's logical error rate while being
labelled with whatever decoder had just been benchmarked.

That is how the workbench export could report two_stage at a 5.0% logical error
rate while 42.5% of two_stage's own corrections failed to reproduce their
syndrome, and colour_code at 29% with a 1% syndrome match rate. The two columns
were measuring different decoders.

Now only kinds whose LER can actually be attributed produce a figure; the rest
return None. A missing number, never a wrong one. syndrome_match_rate remains
per-decoder and is the honest accuracy signal for the others.

Also corrects docs/RELEASING.md: the pre-flight said "expect 221 passed" when
the suite is 303, and pytest must run through dev.bat or 58 CUDA tests fail on
licensing alone.

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

Author: Guillaume Lessard

docs/RELEASING.md

@@ -72,13 +72,21 @@ get **both** CUDA and OpenCL — which is why a locally built extension can expo
 ## Pre-flight checklist
 
 ```bash
-cargo test --no-default-features        # expect 221 passed, 0 failed
+cargo test --no-default-features        # expect 303 passed, 0 failed
 cargo clippy --no-default-features --all-targets   # expect 0 warnings
 ruff check python/                      # expect 0 errors
 ruff format --check python/             # expect no reformatting needed
-python -m pytest python/tests -q        # see test-results/pytest.txt
+dev.bat python -m pytest python/tests -q           # see test-results/pytest.txt
 ```
 
+**Run pytest through `dev.bat`, never bare.** `dev.bat` exports the Enterprise token that
+unlocks the GPU paths. A bare `python -m pytest python/tests` fails 58 CUDA tests
+(`test_max_capacity.py::TestGPUCapacity::test_cuda_large_batch[*]` and
+`test_syndrome_faithfulness.py::test_cuda_bit_identical_and_faithful[*]`) purely on licensing,
+which looks like a broken tree and is not one. Confirm the unlock first with
+`dev.bat python scripts\_verify_enterprise_unlock.py` — expect
+`PASS: Enterprise/GPU unlock is confirmed working.`
+
 Then, from the repo that owns the fulfilment worker:
 
 ```bash

python/qector_decoder_v3/workbench.py

@@ -328,11 +328,36 @@ def _resolve_problems(self, spec, source):
         dists = spec.get("distances", [spec.get("distance", 5)])
         return [(_CODE_FAMILIES[fam](int(d)), None) for d in dists]
 
+    #: Decoder kinds whose LER this method can honestly measure. ``Matching``
+    #: in ``pymatching_compat`` is hard-wired to ``BlossomDecoder``
+    #: (``self._decoder: BlossomDecoder``; ``from_detector_error_model`` takes no
+    #: decoder argument), so it is the only decoder actually exercised here.
+    _LER_MEASURABLE_KINDS = frozenset({"blossom"})
+
     def _ler(self, kind, code, ler_ctx, shots) -> float | None:
-        """Real LER from Stim shots for a stim-loaded problem (graphlike only)."""
+        """Real LER from Stim shots, for the decoder named by ``kind``.
+
+        Returns ``None`` when the LER cannot be attributed to ``kind`` — a
+        missing number, never a wrong one.
+
+        This previously accepted ``kind`` and then ignored it: the body built
+        ``pymatching_compat.Matching.from_detector_error_model(sdem)`` and
+        decoded with that, and ``Matching`` only ever drives ``BlossomDecoder``.
+        Every row therefore carried Blossom's LER while being labelled with
+        whatever decoder had just been benchmarked. That is how a row could
+        report a 5.0% logical error rate while 42.5% of that decoder's own
+        corrections failed to reproduce their syndrome — the two columns were
+        measuring different decoders.
+
+        Until the Stim-shot path can drive an arbitrary decoder, only the kinds
+        in :attr:`_LER_MEASURABLE_KINDS` yield a figure. Read
+        ``syndrome_match_rate`` for the others: it *is* measured per decoder,
+        and a correction that does not reproduce its syndrome is not a valid
+        correction regardless of any logical-error figure.
+        """
+        if kind not in self._LER_MEASURABLE_KINDS:
+            return None
         try:
-            import stim
-
             from . import pymatching_compat
 
             circuit = ler_ctx["circuit"]
@@ -344,6 +369,7 @@ def _ler(self, kind, code, ler_ctx, shots) -> float | None:
             pred = np.asarray(m.decode_batch(det), np.uint8).reshape(shots, -1)
             return float(np.any(pred != obs, axis=1).mean())
         except (ImportError, AttributeError, TypeError, ValueError, RuntimeError):
+            # Unsupported problem shape (e.g. a non-graphlike DEM) or Stim absent.
             return None
 
     # ------------------------------------------------------------- job queue