feat(architectures): add the architecture facet registry

[Pfannkuchensack]

First of a short series that moves per-architecture facts out of core dispatch chains and into one
registry. Spec: .ideas/Backend Modularization Plan.md.

This PR adds no behaviour. It is the scaffolding the following PRs land on, plus the tests that
make an incompletely registered architecture a CI failure rather than a runtime one.

Why

Adding a BaseModelType costs ~16 edited core files. The count is not the problem — the failure
mode is. Most of those edits, when forgotten, fail at generation time, not at boot: a missing
step_callback branch raises Unsupported base model on the first preview, an unregistered
*ConditioningInfo breaks deserialization mid-graph.

What

invokeai/backend/architectures/ — register / get / require / generative_bases /
validate, and one defs/<base>.py per architecture. All 15 register an empty facet set; the
facets themselves arrive in the follow-ups.

facet.py ← registry.py ← facets/*.py ← defs/*.py ← __init__.py ← core

• Facet lives in its own module, not in registry.py. Facet modules need to import the
  registry for their accessors; if Facet were defined in registry.py, the edge
  facets → registry and the edge registry → facets would be one line apart.
• Which facets are mandatory is declared by the facet classes (Facet.REQUIRED), collected via
  __init_subclass__ — the Config_Base.CONFIG_CLASSES pattern. A registry that knew the required
  set would have to import concrete facets. FACET_TYPES is a dict, not a set:
  CONFIG_CLASSES is a set and its non-deterministic iteration order has bitten this repo before
  (tests/backend/model_manager/configs/test_wan_lora_probe_independence.py).
• The defs import list is explicit, not a glob, so a missing definition is distinguishable
  from a base that does not exist. This one line is the intended residual per-architecture edit.
• File names are derived from the enum value (z-image → defs/z_image.py), so require() and
  validate() can compute the file to edit instead of maintaining a second table.

require() names the file to edit:

Architecture 'z-image' is not registered, so it cannot declare LatentSpaceFacet. Create
invokeai/backend/architectures/defs/z_image.py with a `register(BaseModelType.ZImage,
LatentSpaceFacet(...))` call, then add the module to the import list in
invokeai/backend/architectures/__init__.py.

ArchitectureError subclasses ValueError deliberately: it replaces
raise ValueError(f"Unsupported base model: ...") call sites, so existing except ValueError
handlers are unaffected.

Boot validation

validate() raises, unlike the invocation-output check it sits beside in run_app.py — that
one warns because it checks third-party node packs, which may legitimately be broken. Architectures
are first-party and the enum is closed.

It is also called from ApiDependencies.initialize(), covering embedders that never go through
run_app.py. The architectures import in dependencies.py is at module level on purpose:
importing that module is what populates the registry, and add_safe_globals mutates torch
process-globally, so the registry must be complete before initialize() runs — not merely before
it is first read. test_import_isolation pins that in a fresh interpreter.

Honest scope

With no facet declaring itself required yet, validate() is structurally sharp and semantically
empty. The load-bearing gate in this PR is test_registry_completeness, which holds the only copy
of set(BaseModelType) - {Any, External, Unknown} in the tree — production code asks the registry,
because registration is the definition — and checks the defs directory against the registered
set in both directions. That catches a definition module that exists but is never imported and
therefore silently registers nothing.

test_layering

tests/test_imports.py cannot catch import-direction problems: it imports every module into one
shared process, where an order-dependent cycle passes. This parses the sources instead. Two rules
earn their keep — a defs module importing the aggregate is a circular import onto a partially
initialised module (and is the natural thing for a contributor to write), and core reaching past the
facade quietly makes the public surface whatever anyone happened to import.

The allowlist is deliberately narrower than the eventual target, so every widening is a visible line
in the PR that needs it. Imports under if TYPE_CHECKING: count — a type-only edge is still an
architectural edge.

The self-tests are the point: a walker with a bug reports zero violations and stays green forever,
which is this test's only realistic failure mode. Modelled on
invokeai/frontend/webv2/src/architecture/dependencyPolicy.test.ts, including its named rules.

Verification

• pytest tests/backend/architectures — 56 passed
• mypy invokeai/backend/architectures (strict, no override entry in pyproject.toml) — clean
• ruff@0.11.2 check . + format --check — clean
• openapi.json regenerated and compared normalized — identical. No Pydantic class, invocation
  field or enum is touched, so schema.ts and docs/src/generated/invocation-context.json are
  unchanged too.
• Negative probes, both reverted afterwards: an injected defs → core import fails
  test_no_layering_violations with exactly
  defs-allowlist: invokeai.backend.architectures.defs.wan -> invokeai.app.util.step_callback; a
  REQUIRED facet no architecture declares makes validate() report all 15, each naming its file.
• Full suite: 4180 passed. The 9 failures are HF_ENDPOINT-related — a local HuggingFace mirror
  rewrites the URLs these mock-based download tests register adapters for. They pass with the
  variable unset, on this branch.

🤖 Generated with Claude Code