feat(registry): AssetResolver + diffuser supplier curves (Jäger / Aerostrip / PIK / PRK)

Two related changes bundled together because the diffuser curve files
only make sense once the registry namespace they live in exists.

src/registry — new asset-metadata resolver:
- AssetResolver with synchronous resolve(namespace, id) + lazy cache,
  async refresh() for future remote pulls.
- FileBackend (per-id or single-file layouts, case-insensitive) and a
  stub HttpBackend (disabled unless EVOLV_ASSET_REMOTE=1).
- Namespaces: curves, menu, monsterSamples, monsterSpecs, units. Menu
  namespace re-keys by inner softwareType + filename so editors that
  pass either string resolve to the same tree.
- README explains how to add a namespace.
- AssetCategoryManager (datasets/assetData/index.js) becomes a thin
  facade over the resolver so existing consumers don't move.
- 246/246 tests pass — including the 39-test registry suite.

datasets/assetData — file moves + new diffuser data:
- modelData/*.json deleted; curves/*.json is the canonical home.
- New diffuser.json menu tree with GVA, Jäger, Aquaconsult/Entec,
  PIK/PRK suppliers.
- gva-elastox-r.json migrated from the inline _loadSpecs hardcode,
  re-tagged coverageBasis="bottom-coverage-pct" (the legacy 2.4
  elements/m² was a prior mis-conversion; we can't recover the
  original % so it's a single-point curve under key "0").
- jaeger-jetflex-td-65-2-g-epdm-1000.json — extracted from the Jäger
  EPDM-1000mm SSOTE/DWP chart on the data sheet (vector-PDF read).
  SSOTE 8.20→6.40 %/m, DWP 25→48 mbar across Q 2-12 Nm³/h. Single
  coverage (vendor doesn't state test conditions).
- aerostrip-phoenix.json — 4-coverage SOTE family at 4.75 m water
  depth (DD 5/10/15/20 %, flux 10-70 Nm³/h·m²) from the Entec/de
  Winter 2023-11-22 dataset; DWP curve from the 21 % @ 4.05 m chart.
- pik300.json / prk300.json — 5-coverage SOTE + SSOTR (DD 5-25 %)
  with split DWP per model variant, water depth ≈ 4.0 m inferred from
  the SOTE↔SSOTR ratio in the source spreadsheet.

src/configs/diffuser.json:
- New asset.{model, assetTagNumber} block so the editor's selected
  model id survives validation.
- diffuser.density description corrected to "Bottom coverage [%]";
  default 2.4 → 15 (typical fine-bubble install).

src/configs/{rotatingMachine,valve}.json: small alignment edits that
came with the registry phase.

src/menu/asset.js + src/menu/aquonSamples.js: rewritten as facades
over assetResolver, keeping the editor-side cascade behaviour intact.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

test/registry/AssetResolver.test.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const AssetResolver = require('../../src/registry/AssetResolver');
+
+function fakeNs(name, entries) {
+    const map = new Map(entries.map(([k, v]) => [String(k).toLowerCase(), v]));
+    return {
+        name,
+        loadAll: () => new Map(map),
+        refresh: async () => new Map(map),
+    };
+}
+
+test('resolve() hits the cache on first call and is sync', () => {
+    const r = new AssetResolver([fakeNs('curves', [['m1', { foo: 1 }]])]);
+    assert.deepEqual(r.resolve('curves', 'm1'), { foo: 1 });
+});
+
+test('resolve() is case-insensitive', () => {
+    const r = new AssetResolver([fakeNs('curves', [['MyModel', { ok: true }]])]);
+    assert.deepEqual(r.resolve('curves', 'mymodel'), { ok: true });
+    assert.deepEqual(r.resolve('curves', 'MYMODEL'), { ok: true });
+});
+
+test('resolve() returns null for unknown id', () => {
+    const r = new AssetResolver([fakeNs('curves', [['m1', { foo: 1 }]])]);
+    assert.equal(r.resolve('curves', 'm999'), null);
+    assert.equal(r.resolve('curves', ''),     null);
+    assert.equal(r.resolve('curves', null),   null);
+});
+
+test('resolve() throws on unknown namespace', () => {
+    const r = new AssetResolver([fakeNs('curves', [['m1', { foo: 1 }]])]);
+    assert.throws(() => r.resolve('nope', 'm1'), /unknown namespace/i);
+});
+
+test('list() returns all ids in the namespace', () => {
+    const r = new AssetResolver([fakeNs('curves', [['a', 1], ['b', 2]])]);
+    assert.deepEqual(r.list('curves').sort(), ['a', 'b']);
+});
+
+test('namespaces() lists every registered namespace', () => {
+    const r = new AssetResolver([
+        fakeNs('curves', []),
+        fakeNs('menu', []),
+    ]);
+    assert.deepEqual(r.namespaces().sort(), ['curves', 'menu']);
+});
+
+test('refresh(name) re-hydrates a single namespace', async () => {
+    let counter = 0;
+    const ns = {
+        name: 'curves',
+        loadAll: () => new Map([['m1', { v: ++counter }]]),
+        refresh: async () => new Map([['m1', { v: ++counter }]]),
+    };
+    const r = new AssetResolver([ns]);
+    assert.deepEqual(r.resolve('curves', 'm1'), { v: 1 });
+    await r.refresh('curves');
+    assert.deepEqual(r.resolve('curves', 'm1'), { v: 2 });
+});
+
+test('refresh() with no name re-hydrates every namespace', async () => {
+    let cA = 0, cB = 0;
+    const r = new AssetResolver([
+        { name: 'a', loadAll: () => new Map([['x', { v: ++cA }]]), refresh: async () => new Map([['x', { v: ++cA }]]) },
+        { name: 'b', loadAll: () => new Map([['y', { v: ++cB }]]), refresh: async () => new Map([['y', { v: ++cB }]]) },
+    ]);
+    r.resolve('a', 'x');
+    r.resolve('b', 'y');
+    await r.refresh();
+    assert.equal(r.resolve('a', 'x').v, 2);
+    assert.equal(r.resolve('b', 'y').v, 2);
+});
+
+test('constructor rejects malformed namespaces', () => {
+    assert.throws(() => new AssetResolver([{ name: 'x' }]),       /loadAll/);
+    assert.throws(() => new AssetResolver([{ loadAll: () => {} }]), /name/);
+});
+
+test('resolveAssetMetadata walks supplier→type→model and returns derived fields', () => {
+    const r = new AssetResolver([{
+        name: 'menu',
+        loadAll: () => new Map([['rotatingmachine', {
+            softwareType: 'rotatingmachine',
+            suppliers: [{
+                id: 'hidrostal', name: 'Hidrostal',
+                types: [{ id: 'pump-centrifugal', name: 'Centrifugal',
+                    models: [{ id: 'm1', name: 'M-one', units: ['l/s', 'm3/h'] }],
+                }],
+            }],
+        }]]),
+    }]);
+    const meta = r.resolveAssetMetadata('rotatingmachine', 'm1');
+    assert.equal(meta.supplier, 'Hidrostal');
+    assert.equal(meta.type,     'Centrifugal');
+    assert.equal(meta.model,    'M-one');
+    assert.deepEqual(meta.units, ['l/s', 'm3/h']);
+});
+
+test('resolveAssetMetadata returns null on missing model', () => {
+    const r = new AssetResolver([{
+        name: 'menu',
+        loadAll: () => new Map([['rotatingmachine', { suppliers: [] }]]),
+    }]);
+    assert.equal(r.resolveAssetMetadata('rotatingmachine', 'm-nope'), null);
+    assert.equal(r.resolveAssetMetadata('rotatingmachine', null),     null);
+    assert.equal(r.resolveAssetMetadata(null,              'm1'),     null);
+});