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/utils/test_root_paths.py

@@ -0,0 +1,69 @@
+import os
+
+import pytest
+
+from py.utils.root_paths import normalize_root_identity
+
+
+def test_folds_windows_and_posix_separators():
+    """ComfyUI's normpath output and LoRA Manager's forward slashes agree."""
+
+    assert normalize_root_identity("E:\\StableDiffusion\\cc_models\\loras") == (
+        normalize_root_identity("E:/StableDiffusion/cc_models/loras")
+    )
+
+
+def test_folds_drive_letter_case_on_every_platform():
+    """A drive letter is case-insensitive even where the filesystem is not."""
+
+    assert normalize_root_identity("E:/models/loras") == normalize_root_identity(
+        "e:/models/loras"
+    )
+    assert normalize_root_identity("E:\\models\\loras") == normalize_root_identity(
+        "e:/MODELS/loras"
+    )
+
+
+def test_folds_trailing_and_redundant_separators():
+    assert normalize_root_identity("E:/models/loras/") == normalize_root_identity(
+        "E:/models/loras"
+    )
+    assert normalize_root_identity("E:/models/other/../loras") == (
+        normalize_root_identity("E:/models/loras")
+    )
+
+
+def test_keeps_posix_case_significant():
+    """Only Windows compares whole paths case-insensitively."""
+
+    if os.name == "nt":
+        assert normalize_root_identity("C:/Models/Loras") == (
+            normalize_root_identity("c:/models/loras")
+        )
+    else:
+        assert normalize_root_identity("/data/Loras") != normalize_root_identity(
+            "/data/loras"
+        )
+
+
+def test_folds_whole_path_case_on_windows(monkeypatch):
+    """The Windows branch is exercised on every platform."""
+
+    monkeypatch.setattr(os, "name", "nt")
+
+    assert normalize_root_identity("C:/Models/Loras") == normalize_root_identity(
+        "c:/models/loras"
+    )
+    assert normalize_root_identity("C:\\Models\\Loras\\") == "c:/models/loras"
+
+
+def test_never_resolves_symlinks_or_abspath():
+    """Business paths stay business paths: only the spelling is folded."""
+
+    assert normalize_root_identity("./models/loras") == "models/loras"
+    assert normalize_root_identity("/srv/link/loras") == "/srv/link/loras"
+
+
+@pytest.mark.parametrize("value", ["", "   ", None, 42])
+def test_blank_inputs_have_no_identity(value):
+    assert normalize_root_identity(value) == ""