fix(scanner): compare model roots by identity, not by spelling (#1146)

ComfyUI hands its model folders over in the host's own spelling --
`utils/extra_config.py` runs every configured path through `os.path.normpath()`,
which is all backslashes on Windows, and `main.py` registers `<output>/loras`
unconditionally for its save nodes. `Config` kept that spelling verbatim while
`_prepare_*_paths()` normalized the live root lists to forward slashes, and the
scanner compared the two as raw strings. On Windows every configured root
therefore looked like a root that was not in the live list: the Refresh menu
listed each directory twice (the twin showing "0 models"), the completion toast
claimed reachable roots were "currently inaccessible" and kept their whole cache
count as `kept_unreachable`, and the settings sync persisted host-registered
directories that were never created.

The duplication was not only cosmetic. `_UnreachablePaths.add()` normalizes the
prefix it is given, so the configured twin of a live root registered exactly the
live root's prefix as unreadable: in the prune phase every cached-but-missing
entry under it matched and was "kept", so models deleted from disk were never
removed from the cache again.

* `py/utils/root_paths.py` holds the single `normalize_root_identity()`
  (separator style, redundant/trailing separators, and case where the filesystem
  folds it: whole paths on Windows, drive letters everywhere). `config.py` and
  `settings_manager.py` each carried a private copy and `model_scanner.py`
  compared raw strings.
* `ModelScanner` compares root identities in `get_configured_model_roots()`,
  `describe_model_roots()` (dedupe + `available`), the reconcile's
  `configured_only` list and the `ReconcileScope.roots` membership test, so one
  directory is one root whatever the host called it. `_normalized_root_prefix()`
  is built on the same identity, and an empty prefix no longer matches every
  path.
* A configured root that never made it into the live list is reported only while
  it still holds cached entries -- in the menu and in `skipped_roots` /
  `unavailable_paths` alike. A directory that neither exists nor was ever scanned
  has nothing to keep, so `<output>/loras` stops being an unavailable root.
* The startup sync drops saved roots that neither exist nor hold cached entries
  (`PersistentModelCache.roots_with_cached_entries()`, one scan per model type,
  separator-agnostic and wildcard-escaped). A root named by the library's
  `default_*_root` is kept even when empty: dropping it would let the next boot
  "repair" the default onto another root. When the cache cannot be consulted,
  every root is kept.
* `GET /scan?roots=` validates requested roots by identity too, so the browser
  extension or a script passing the spelling settings.json holds selects the root
  instead of answering 400 "Unknown model root(s)".

Verified: 8 of the new tests fail against the pre-fix source (checked with the
fix stashed); 3798 passed, 7 skipped, 11 deselected. The probe costs 71ms for a
100k-model library with seven missing roots (357ms when probing root by root).

tests/routes/test_model_query_handler.py

@@ -316,6 +316,32 @@ async def test_scan_models_rejects_unknown_root():
     assert service.received_scope == "not-called"
 
 
+@pytest.mark.asyncio
+async def test_scan_models_accepts_a_root_in_the_hosts_own_spelling():
+    """Windows callers may pass a root the way ComfyUI spells it (issue #1146).
+
+    ``settings.json`` and the ComfyUI logs show ``E:\\loras`` while the live list
+    holds ``E:/loras``; both name the same directory, so a scoped scan must select
+    it instead of answering 400 "Unknown model root(s)".
+    """
+    service = ScopedScanService(
+        roots=["E:/StableDiffusion/cc_models/loras"], summary=SUMMARY
+    )
+    handler = ModelQueryHandler(service=service, logger=logging.getLogger(__name__))
+
+    for requested in (
+        "E:\\StableDiffusion\\cc_models\\loras",
+        "e:/StableDiffusion/cc_models/loras",
+    ):
+        service.received_scope = "not-called"
+        response = await handler.scan_models(
+            SimpleNamespace(query=QueryParams({"roots": [requested]}))
+        )
+
+        assert response.status == 200, requested
+        assert service.received_scope.roots == (requested,)
+
+
 @pytest.mark.asyncio
 async def test_scan_models_rejects_roots_with_full_rebuild():
     service = ScopedScanService(roots=["/mnt/a"], summary=SUMMARY)