Close the SettingsClassGenerator concurrency race (T7)

[guy-lud]

T7 — close the SettingsClassGenerator concurrency race

GenerateType did a lock-free TryGetValue and, on a miss, called _moduleBuilder.DefineType(name) then wrote the cache. Two problems under concurrency:

1. Same interface: two threads both miss the cache and both DefineType the same name → the second throws Duplicate type name within an assembly → the resolve/scan aborts (TypeGenerationException).
2. Distinct interfaces: System.Reflection.Emit is not thread-safe — concurrent DefineType calls (even with different names) race the shared ModuleBuilder's metadata/token state.

Q4's ConcurrentDictionary made the cache thread-safe but never serialized the check-then-define.

Reachable in production: GenericHost registers ISettingsProvider as a process-wide singleton over one SettingsBuilder; cache-miss resolves fall through to lazy generation on the shared ModuleBuilder from concurrent DI resolutions (request threads, hosted services).

Fix — double-checked locking

• Warm cache-hit path stays lock-free (TryGetValue before the lock).
• On a miss: take a single _generationGate, re-check, run the whole emit sequence (DefineImplementationType: name → extract → DefineType → AddInterfaceImplementation → properties → CreateTypeInfo) and the cache write inside the lock; failures still wrap as TypeGenerationException (uncached → retryable for pre-DefineType failures).
• One gate over ALL generation, matching the shared _moduleBuilder's scope — deliberately not a Lazy<Type>-per-type, which only serializes same-interface generation and would leave the distinct-interface module race open.

Tests (+2, suite 84 net10, 5× green)

• GenerateType_ConcurrentSameInterface_ReturnsSingleSharedType — 128 Parallel.For iterations on one interface → single shared impl (this one has teeth: pre-fix it very likely hits the duplicate-name throw).
• GenerateType_ConcurrentAcrossSameAndDistinctInterfaces_IsRaceFree — 32 explicit threads + a Barrier across 8 interfaces (same- and distinct-interface contention at once) → no failures, exactly one impl per interface. Regression-guards the lock-all decision.

Review

• Plan reviewed by dotnet-architect — ENDORSE-WITH-CHANGES: confirmed lock-all is required (Reflection.Emit races the shared ModuleBuilder for distinct types too), so Lazy-per-type was rejected; DCL shape and lock scope verified. Perf/security in-context (off the hot path; no security surface).
• Code reviewed via /code-review (high) + Roslyn detect_antipatterns (0). Build clean, both TFMs.

Non-breaking (internal behavior only). Follows #27 (S1) and #28 (C2).