refactor(8.0)!: remove orphaned zero-config subsystem + dead cloud/progressive-init storage vestige

The old config-generation subsystem (src/config/ + autoConfiguration.ts) was
superseded during the 8.0 rework and never wired into init(): it emitted settings
for a partitioning subsystem that no longer exists and probed deleted cloud env
vars. The live zero-config path is inline — recall preset → HNSW knobs, storage
auto-detect, auto persistMode, container-memory-aware cache sizing.

The storage progressive-init / cloud-detection cluster was equally dead after the
cloud adapters were dropped: isCloudStorage() is permanently false (no overriders),
scheduleBackgroundInit/runBackgroundInit were never called (the latter an empty
body), initMode was never assigned, and Brainy.isFullyInitialized()/
awaitBackgroundInit() were always-trivial with zero callers. scheduleCountPersist()
collapses to its only-ever-taken immediate write-through path.

Removed:
- src/config/{index,zeroConfig,storageAutoConfig,modelAutoConfig,sharedConfigManager}.ts
- src/utils/autoConfiguration.ts + the inert BrainyZeroConfig export
- Brainy.isFullyInitialized()/awaitBackgroundInit() (+ BrainyInterface decls)
- InitMode type, isCloudStorage/detectCloudEnvironment/resolveInitMode,
  scheduleBackgroundInit/runBackgroundInit/ensureValidatedForWrite and their state
- Dead cloud env-var probes (K_SERVICE/K_REVISION/AWS_LAMBDA_FUNCTION_NAME/
  FUNCTIONS_TARGET/AZURE_FUNCTIONS_ENVIRONMENT)

Kept (verified live): production-detection logging (environment.ts), container-
memory cache sizing (memoryDetection/paramValidation), on-disk hash bucketing
(sharding.ts).

Docs: scrubbed deleted-subsystem references (JS quantization knobs, cloud/OPFS
adapters, partitioning, old zero-config API) across 14 files; deleted two wholly-
obsolete feature docs (complete-feature-list, v3-features); rewrote
architecture/zero-config for 8.0.

~3,700 LOC removed. Build clean; 1392 unit + 24 db-mvcc green.

src/brainy.ts

@@ -172,19 +172,6 @@ interface MetadataIndexOptionalHooks {
   close?: () => Promise<void> | void
 }
 
-/**
- * Optional progressive-initialization surface implemented by cloud storage
- * adapters (plugin-provided in 8.0 — the built-in filesystem/memory adapters
- * complete their full init synchronously inside `init()` and don't expose
- * these). Feature-detected with `typeof x === 'function'` before invoking.
- */
-interface StorageBackgroundInitHooks {
-  /** Whether all background init tasks (bucket validation, count sync) finished. */
-  isBackgroundInitComplete?: () => boolean
-  /** Resolves when all background init tasks complete. */
-  awaitBackgroundInit?: () => Promise<void>
-}
-
 /**
  * Brainy's internal resolved configuration. `normalizeConfig()` defaults every
  * field at construction except the genuinely-optional ones listed in the
@@ -1075,13 +1062,12 @@ export class Brainy<T = any> implements BrainyInterface<T> {
    * This Promise is created in the constructor and resolves when init() completes.
    * It can be awaited multiple times safely - the result is cached.
    *
-   * This enables reliable readiness detection for consumers,
-   * especially in cloud environments where progressive initialization means
-   * init() returns quickly but background tasks may still be running.
+   * This enables reliable readiness detection for consumers — await it
+   * before issuing queries when init() was fired without awaiting.
    *
    * @example Waiting for readiness before API calls
    * ```typescript
-   * const brain = new Brainy({ storage: { type: 'gcs', ... } })
+   * const brain = new Brainy()
    * brain.init() // Fire and forget
    *
    * // Elsewhere in your code (e.g., API handler)
@@ -1115,82 +1101,6 @@ export class Brainy<T = any> implements BrainyInterface<T> {
     return this._readyPromise
   }
 
-  /**
-   * Check if Brainy is fully initialized including all background tasks
-   *
-   * This checks both:
-   * 1. Basic initialization complete (init() returned)
-   * 2. Storage background tasks complete (bucket validation, count sync)
-   *
-   * Useful for determining if all lazy/progressive initialization is done.
-   *
-   * @returns true if all initialization including background tasks is complete
-   *
-   * @example Health check with background status
-   * ```typescript
-   * app.get('/health', (req, res) => {
-   *   res.json({
-   *     ready: brain.isInitialized,
-   *     fullyInitialized: brain.isFullyInitialized(),
-   *     status: brain.isFullyInitialized() ? 'ready' : 'warming'
-   *   })
-   * })
-   * ```
-   */
-  isFullyInitialized(): boolean {
-    if (!this.initialized) return false
-
-    // Check if storage has background init methods (cloud storage adapters)
-    const storage = this.storage as BaseStorage & StorageBackgroundInitHooks
-    if (typeof storage?.isBackgroundInitComplete === 'function') {
-      return storage.isBackgroundInitComplete()
-    }
-
-    // Non-cloud storage adapters are fully initialized after init()
-    return true
-  }
-
-  /**
-   * Wait for all background initialization tasks to complete
-   *
-   * For cloud storage adapters with progressive initialization,
-   * this waits for:
-   * - Bucket/container validation
-   * - Count synchronization
-   * - Any other background tasks
-   *
-   * For non-cloud storage, this resolves immediately.
-   *
-   * **Use Case**: Call this when you need guaranteed consistency, such as:
-   * - Before running batch operations
-   * - Before reporting full system health
-   * - When transitioning from "initializing" to "ready" status
-   *
-   * @returns Promise that resolves when all background tasks complete
-   *
-   * @example Ensuring full initialization
-   * ```typescript
-   * const brain = new Brainy({ storage: { type: 'gcs', ... } })
-   * await brain.init()  // Fast return in cloud (<200ms)
-   *
-   * // Optional: wait for background tasks if needed
-   * await brain.awaitBackgroundInit()
-   * console.log('All background tasks complete')
-   * ```
-   */
-  async awaitBackgroundInit(): Promise<void> {
-    // Must be initialized first
-    await this.ready
-
-    // Check if storage has background init methods (cloud storage adapters)
-    const storage = this.storage as BaseStorage & StorageBackgroundInitHooks
-    if (typeof storage?.awaitBackgroundInit === 'function') {
-      await storage.awaitBackgroundInit()
-    }
-
-    // Non-cloud storage: no background init to wait for
-  }
-
   // ============= CORE CRUD OPERATIONS =============
 
   /**