DC-005: Fix all 138 broken test paths after src/ refactor

After the DC-005 module reorganization (41 files moved into src/ subdirs),
138 test suites failed because the refactor script's path-rewrite logic
missed three categories:

1. Files inside src/ doing 'require("./src/...")' — should be 'require("../...")'
2. Files in src/X/Y/ doing 'require("../../../src/...")' — should be 'require("../../...")'
3. Test files in __tests__/ with leftover 'require("../../../src/...")' paths

Root cause: the original refactor script ran before all files were moved,
so it computed relative paths against stale filesystem state.

Result:
- 30/30 test suites pass
- 879/879 tests pass (was: 18/30 suites, 614/687 tests)

Also fixed:
- routes/apps/restore.js: wrong responses import path
- routes/*/*.js: '../../src/utilities/X' → '../src/utilities/X' (depth 2 routes)

dashcaddy-api/src/dns/dns-providers/registry.js

@@ -0,0 +1,101 @@
+/**
+ * DNS Provider Registry
+ * Manages available DNS provider adapters.
+ * Providers register themselves, and the active provider is selected by config.
+ */
+const path = require('path');
+
+class DNSProviderRegistry {
+  constructor() {
+    this.providers = new Map();    // providerId -> adapter class
+    this.instances = new Map();    // providerId -> adapter instance
+  }
+
+  /** Register a provider adapter class */
+  register(adapterClass) {
+    const instance = new adapterClass({}, {});
+    const id = instance.providerId;
+    if (this.providers.has(id)) {
+      console.warn(`DNS provider "${id}" already registered, overwriting`);
+    }
+    this.providers.set(id, adapterClass);
+  }
+
+  /** Get list of all registered provider IDs */
+  getProviderIds() {
+    return Array.from(this.providers.keys());
+  }
+
+  /** Get metadata for all providers (without instantiating with real config) */
+  getProviderMeta() {
+    return this.getProviderIds().map(id => {
+      const Adapter = this.providers.get(id);
+      const inst = new Adapter({}, {});
+      return {
+        id: inst.providerId,
+        displayName: inst.displayName,
+        capabilities: inst.getCapabilities()
+      };
+    });
+  }
+
+  /** 
+   * Get or create an adapter instance for the given provider + config
+   * @param {string} providerId - The provider to instantiate
+   * @param {Object} config - Provider-specific configuration
+   * @param {Object} ctx - Shared application context
+   * @returns {BaseDNSProvider} The provider adapter instance
+   */
+  getProvider(providerId, config, ctx) {
+    // Re-create if config changed
+    const cacheKey = providerId;
+    const Adapter = this.providers.get(providerId);
+    if (!Adapter) {
+      throw new Error(`Unknown DNS provider: ${providerId}. Available: ${this.getProviderIds().join(', ')}`);
+    }
+    const instance = new Adapter(config, ctx);
+    this.instances.set(cacheKey, instance);
+    return instance;
+  }
+
+  /** Auto-discover and register all providers in this directory */
+  autoDiscover() {
+    const fs = require('fs');
+    const dir = __dirname;
+    const files = fs.readdirSync(dir).filter(f => 
+      f !== 'base.js' && f !== 'registry.js' && f.endsWith('.js') && !f.startsWith('.')
+    );
+    for (const file of files) {
+      try {
+        const Loaded = require(path.join(dir, file));
+        // Support: module.exports = Class, module.exports = { Class }, or plain objects
+        let cls = null;
+        if (typeof Loaded === 'function') {
+          cls = Loaded;
+        } else if (typeof Loaded === 'object' && Loaded !== null) {
+          // Try to find a class in the exported object
+          cls = Object.values(Loaded).find(v => typeof v === 'function');
+        }
+        if (cls) {
+          // Verify it has providerId (on prototype or set in constructor)
+          try {
+            const test = new cls({}, {});
+            if (test.providerId && typeof test.getCapabilities === 'function') {
+              this.register(cls);
+            }
+          } catch {
+            // Not a valid provider adapter, skip
+          }
+        }
+      } catch (err) {
+        console.error(`Failed to load DNS provider from ${file}:`, err.message);
+      }
+    }
+  }
+}
+
+// Singleton
+const registry = new DNSProviderRegistry();
+registry.autoDiscover();
+
+module.exports = registry;