test: corriger 4 défauts de classification du chantier B

L'audit a identifié que la classification automatique du commit B2
avait mal placé 23 fichiers dans des sous-dossiers qui ne reflètent
pas le sujet réel du test.

**1. 13 tests ``tests/core/`` → ``tests/measurements/``**

L'algorithme ``Counter.most_common()`` privilégiait l'ordre
alphabétique en cas d'égalité ; comme les tests métriques importaient
fréquemment 1-2 modules ``picarones.core.*`` (``metric_registry``,
``modules``) en plus du module ``picarones.measurements.X`` testé,
ils étaient classés en ``core/``.

Tests concernés : ``test_sprint{38,52,53,55,56,57,58,59,60,64,65,84,85}_*``
— tous testent un module sous ``picarones.measurements/``.

**2. 6 tests ``_html`` ``tests/measurements/`` → ``tests/report/``**

Les tests dont le nom comporte le suffixe ``_html`` testent
explicitement le **rendu HTML** d'une métrique (renderer dans
``picarones.report.*_render``). Ils croisent ``measurements`` et
``report`` mais leur sujet principal est le rendu :
``test_sprint{46_stratification,67_pipeline,68_pipeline_comparison,86_aii5,87_readability,88_robustness_projection}_html``.

**3. 4 tests ambigus reclassés**

- ``test_sprint69_user_doc.py`` (était en ``core/``) → ``integration/``
(test du contenu de ``docs/user/`` — pas une abstraction cercle 1).
- ``test_sprint13_parallelisation_stats.py`` (``measurements/`` →
``integration/``) — teste le runner parallèle via 5 adapters OCR
simultanément, c'est un test E2E.
- ``test_sprint7_advanced_report.py`` (``measurements/`` → ``report/``)
— teste ``ReportGenerator``, pas une métrique.
- ``test_sprint28_ux_save_compare.py`` (``report/`` → ``web/``) —
teste les endpoints ``/api/config/save``, ``/api/config/load``,
``/api/benchmark/{job_id}/synthesis_preview``, etc. C'est un test
HTTP, pas un test de rendu.

**4. ``conftest.py`` racine scindé**

Avant : ``tests/conftest.py`` exposait une fixture
``autouse=True _isolate_web_app_state`` qui s'appliquait à **tous**
les tests, même ceux des cercles 1 et 2 qui n'utilisaient jamais
``picarones.web.*``. Conséquences :

- Chaque test ``tests/core/test_corpus.py`` chargeait inutilement
``picarones.web.app`` à chaque exécution (plusieurs ms d'I/O
d'import × 3354 tests = pollution mesurable).
- L'isolation web mutait l'état global même quand non pertinent.

Après :

- ``tests/conftest.py`` réduit à ~30 lignes — ne fait plus que
positionner les ``os.environ.setdefault`` AVANT le premier import
de ``picarones.web.*``. C'est une opération à exécuter une fois,
pas par-test.
- ``tests/web/conftest.py`` (nouveau) — contient la fixture
``autouse=True``, automatiquement scopée aux tests sous
``tests/web/``. Le ``try/except ImportError`` est supprimé
puisqu'on est garanti que les imports ``picarones.web.*``
réussissent dans ce contexte.

Répartition finale
------------------

tests/core/ 10 fichiers (-13)
tests/measurements/ 49 fichiers (-3 ; -6 _html ; +13 from core)
tests/engines/ 9 fichiers (inchangé)
tests/report/ 21 fichiers (+1 sprint7 ; +6 _html ; -1 sprint28)
tests/web/ 5 fichiers (+1 sprint28)
tests/extras/ 1 fichier (inchangé)
tests/cli/ 1 fichier (inchangé)
tests/integration/ 12 fichiers (+2 ambigus)

Pytest : 3354 passed, 2 skipped, 0 failed (inchangé).
Ruff : All checks passed.

https://claude.ai/code/session_01Hsd7kL8yeCbXn1mA7GQK9L

tests/conftest.py

@@ -1,88 +1,30 @@
 """Configuration pytest globale.
 
-Picarones expose dans ``picarones.web.state`` trois états globaux
-partagés :
-  - un sémaphore borné (``JOBS_SEMAPHORE``) pour les benchmarks
-    concurrents,
-  - un rate limiter par IP (``RATE_LIMITER``),
-  - une liste cachée de browse roots dérivée à l'import dans
-    ``picarones.web.routers.corpus._BROWSE_ROOTS``.
-
-Ces états peuvent polluer des tests indépendants. Ce conftest :
-
-1. Force des défauts test-friendly via env vars **avant** l'import
-   du module ``picarones.web.app`` — sinon le sémaphore est déjà
-   créé avec la valeur prod (2) au moment où le premier test
-   l'utilise.
-2. Restaure l'état entre chaque test via une fixture autouse qui
-   purge le rate limiter, ré-injecte un sémaphore frais, et recalcule
-   les browse roots selon l'environnement courant.
+Ce conftest racine ne fait **qu'une seule chose** : positionner les
+variables d'environnement test-friendly **avant** tout import de
+``picarones.web.*``. Sans ça, les singletons web (``JOBS_SEMAPHORE``,
+``RATE_LIMITER``) seraient instanciés avec les valeurs de production
+(2 jobs concurrents max, rate limit selon mode public) au moment du
+premier import, et chaque test web verrait le bocal saturé.
+
+L'isolation par-test des états globaux web (sémaphore, rate limiter,
+browse roots) vit dans ``tests/web/conftest.py`` — fixture
+``autouse=True`` qui ne s'applique qu'aux tests sous ``tests/web/``,
+pour éviter qu'un test cercle 1 (``tests/core/``) ne paie le coût
+de l'import de ``picarones.web.*`` à chaque exécution.
 """
 
 from __future__ import annotations
 
 import os
-import threading
-
-import pytest
-
 
-# ---------------------------------------------------------------------------
-# Defaults test-friendly à appliquer AVANT tout import de l'app FastAPI.
-# ---------------------------------------------------------------------------
-
-# Plafond très large pour ne jamais bloquer une suite de tests qui démarre
-# rapidement plusieurs benchmarks daemon (Sprint 6 + Sprint 24).
+# Plafond très large pour ne jamais bloquer une suite de tests qui
+# démarre rapidement plusieurs benchmarks daemon en parallèle.
 os.environ.setdefault("PICARONES_MAX_CONCURRENT_JOBS", "32")
-# S'assurer qu'on est en mode dev pour les tests existants ; les tests
-# Sprint 24 qui valident le mode public le forcent eux-mêmes via monkeypatch.
-os.environ.pop("PICARONES_PUBLIC_MODE", None)
-# Rate limit désactivé en dev (déjà le cas, mais explicite).
-os.environ.setdefault("PICARONES_RATE_LIMIT_PER_HOUR", "0")
-
 
-# ---------------------------------------------------------------------------
-# Fixture d'isolation : purge l'état global avant chaque test.
-# ---------------------------------------------------------------------------
-
-@pytest.fixture(autouse=True)
-def _isolate_web_app_state():
-    """Réinitialise sémaphore, rate limiter et browse roots entre tests.
-
-    Sans cette fixture :
-      - une suite séquentielle de 32+ tests qui font ``POST /api/benchmark/*``
-        peut épuiser le sémaphore (les threads daemon ne libèrent qu'à la
-        fin du benchmark Tesseract, qui prend une fraction de seconde mais
-        plusieurs tests consécutifs se bousculent) ;
-      - un test Sprint 24 qui mute ``_BROWSE_ROOTS`` localement laisse une
-        liste pointant vers un ``tmp_path`` purgé ;
-      - les tests qui appellent le rate limiter directement laissent des
-        timestamps dans son bucket.
-    """
-    try:
-        from picarones.web import app as web_app
-        from picarones.web import security as web_sec
-        from picarones.web import state as web_state
-        from picarones.web.routers import corpus as web_corpus_router
-    except ImportError:
-        # Tests non-web : aucun état à restaurer.
-        yield
-        return
-
-    # Sauvegarde
-    original_browse_roots = list(web_corpus_router._BROWSE_ROOTS)
-
-    # Sémaphore frais à chaque test (capacité large, voir conftest top-level).
-    # Le module ``state`` détient le singleton ; ``app`` en a juste une
-    # référence (importée comme ``_JOBS_SEMAPHORE``) — on synchronise les deux.
-    new_sem = threading.Semaphore(web_sec.get_max_concurrent_jobs())
-    web_state.JOBS_SEMAPHORE = new_sem
-    web_app._JOBS_SEMAPHORE = new_sem
-    web_state.RATE_LIMITER.reset()
-    web_state.RATE_LIMITER.max_per_hour = web_sec.get_rate_limit_per_hour()
-
-    yield
+# Mode dev par défaut. Les tests qui valident le mode public le
+# forcent eux-mêmes via ``monkeypatch.setenv("PICARONES_PUBLIC_MODE", "1")``.
+os.environ.pop("PICARONES_PUBLIC_MODE", None)
 
-    # Restauration
-    web_corpus_router._BROWSE_ROOTS[:] = original_browse_roots
-    web_state.RATE_LIMITER.reset()
+# Rate limit désactivé en dev (déjà le défaut, explicité ici).
+os.environ.setdefault("PICARONES_RATE_LIMIT_PER_HOUR", "0")

tests/web/conftest.py

@@ -0,0 +1,66 @@
+"""Fixtures locales aux tests de l'interface web FastAPI.
+
+Le serveur Picarones expose dans :mod:`picarones.web.state` trois
+états globaux partagés entre routes :
+
+- ``JOBS_SEMAPHORE`` — sémaphore borné pour les benchmarks concurrents,
+- ``RATE_LIMITER`` — rate limiter par IP,
+- ``picarones.web.routers.corpus._BROWSE_ROOTS`` — répertoires
+  autorisés à la navigation, calculés au chargement.
+
+Ces états peuvent polluer des tests indépendants. Cette fixture
+réinitialise les trois entre chaque test web — purge le rate
+limiter, ré-injecte un sémaphore frais, recalcule les browse roots
+selon l'environnement courant.
+
+Discipline : la fixture est ``autouse=True`` mais n'est définie
+que dans ``tests/web/conftest.py`` — les tests des cercles 1 et 2
+(``tests/core/``, ``tests/measurements/``, etc.) ne paient pas le
+coût de l'import de ``picarones.web.*`` à chaque test.
+"""
+
+from __future__ import annotations
+
+import threading
+
+import pytest
+
+
+@pytest.fixture(autouse=True)
+def _isolate_web_app_state():
+    """Réinitialise sémaphore, rate limiter et browse roots entre tests.
+
+    Sans cette fixture :
+
+    - une suite séquentielle de 32+ tests qui font ``POST /api/benchmark/*``
+      peut épuiser le sémaphore (les threads daemon ne libèrent qu'à la
+      fin du benchmark Tesseract, qui prend une fraction de seconde mais
+      plusieurs tests consécutifs se bousculent) ;
+    - un test qui mute ``_BROWSE_ROOTS`` localement laisse une liste
+      pointant vers un ``tmp_path`` purgé ;
+    - les tests qui appellent le rate limiter directement laissent des
+      timestamps dans son bucket.
+    """
+    from picarones.web import app as web_app
+    from picarones.web import security as web_sec
+    from picarones.web import state as web_state
+    from picarones.web.routers import corpus as web_corpus_router
+
+    # Sauvegarde
+    original_browse_roots = list(web_corpus_router._BROWSE_ROOTS)
+
+    # Sémaphore frais à chaque test (capacité large, voir les env vars
+    # par défaut dans ``tests/conftest.py``). Le module ``state``
+    # détient le singleton ; ``app`` en a une référence importée comme
+    # ``_JOBS_SEMAPHORE`` — on synchronise les deux.
+    new_sem = threading.Semaphore(web_sec.get_max_concurrent_jobs())
+    web_state.JOBS_SEMAPHORE = new_sem
+    web_app._JOBS_SEMAPHORE = new_sem
+    web_state.RATE_LIMITER.reset()
+    web_state.RATE_LIMITER.max_per_hour = web_sec.get_rate_limit_per_hour()
+
+    yield
+
+    # Restauration
+    web_corpus_router._BROWSE_ROOTS[:] = original_browse_roots
+    web_state.RATE_LIMITER.reset()