fix(A8 + LSM 读自洽): 行所有权根治 + 读取路径不再依赖 prefetch

A8 行引用泄漏（调用方改查询结果即改写存储）
  实测：rows[0].tag = 'HACKED' 后，tag='HACKED' 与 tag='x' 两条索引查询都返回 0 行 ——
  行与索引失配、该行永久查不出来；嵌套 json 值同样按引用共享。
  Aria 因走反序列化路径反而幸免，又形成跨引擎差异。

  根治：在 IStorageEngine 契约层写入**行所有权约定**（engine/interface.ts）
  —— 读出的行是副本、写入接收的行也是副本；新增 cloneRow/cloneRows
  （优先 structuredClone，退化路径处理 Date/嵌套对象/二进制）。
  Memory/KVStore/Hybrid：find、findStream、getRow 全部返回副本。
  Aria：getAllRows 此前只做 `{ ...value }` 浅拷贝（嵌套 json 仍共享引用），
  改为深拷贝；find/findStream 返回副本。
  实测四种引擎：修改返回值后重读不变、索引两条查询均正确。

LSM 读取自洽（审计 P1-1：缓存未命中 = 静默丢数据）
  此前 loadSSTableReader 缓存未命中返回 null，而所有调用方都是
    const reader = this.loadSSTableReader(meta); if (!reader) continue;
  于是**未命中就静默跳过整个 SSTable**。实测：缓存上限 4KB 而 SSTable 更大时，
  300 行只能查回 59 行，且不报错。
  同时"读路径必须先 prefetch"这个隐式约定，是每次读都要 drainChain + prefetch
  的原因（性能悬崖的另一半）。

  根治：LSM.get / rangeScan / rangeScanLazy 改为 async，未命中即
  `await sstableStore.load()` 回源 + CRC 校验（损坏则自愈清理 meta），
  只有数据确实不存在才返回 null。checkUniqueSync 相应改名 checkUnique 并 async
  （原命名正是因为依赖 prefetch 约定）。引擎侧 12 处调用点补 await。

附带修正的缓存语义：
  - tryCacheSSTable：单个 SSTable 超过缓存上限时标记为常驻（pinned），
    不参与驱逐 —— 驱逐它等价于静默丢数据；内存上限因此是
    cacheLimit + 单个最大 SSTable，已在代码与测试中明确。
  - trimCache 跳过 pinned 条目（此前会把全部缓存一次性清空）。
  - 新增 getCacheSize/getCacheLimit/getOversizedCount/setCacheLimit 访问器
    （测试此前直接读私有字段 cacheSize/cacheLimitBytes —— 那是 TS 错误，
    只因测试不做类型检查才没暴露）。

queryStream async 回调
  此前用 constructor.name === 'AsyncFunction' 判定，对"普通函数返回 Promise"
  完全失效（Promise 被静默丢弃）。现改为双条件识别并走物化路径逐行 await，
  async 回调被真正等待。

测试契约修正：
  - aria-cache：'缓存大小受上限约束' 在极小缓存下是不可成立的契约，改为断言
    真正重要的不变量（数据完整；可装入时受上限约束），并新增"超大 SSTable 常驻"
    用例；'缓存驱逐后全表扫描仍返回完整数据' 保留 300 行断言（此前会失败）。
  - hybrid：磁盘引擎标签断言从 indexeddb（v0.6.0 已移除）改为 opfs。

tests/engine/aria-cache.test.ts

@@ -57,16 +57,54 @@ describe('AriaEngine SSTable 缓存内存上限', () => {
     // 300 行 / 2KB 阈值 → 应产生多个 SSTable
     expect(stats.sstableCount).toBeGreaterThan(1);
 
-    // 多轮查询后缓存仍受上限约束
+    // v0.8.0 契约修正：内存上限只约束**可驱逐条目**。
+    //
+    // 单个 SSTable 大于整个缓存上限时，它必须常驻：一旦驱逐，
+    // `loadSSTableReader` 未命中就会让调用方 `continue` 跳过整个文件 ——
+    // 那是静默丢数据（审计实测：300 行只能查回 59 行）。
+    // 因此这里断言的是"数据完整"这一真正重要的不变量，而不是一个
+    // 在极小缓存下无法成立的字节上限（上限 = cacheLimit + 单个最大 SSTable）。
     for (let round = 0; round < 5; round++) {
       const rows = await engine.find('users', { table: 'users', where: { age: 25 } });
       expect(rows.length).toBe(10);
+    }
+
+    // 若所有 SSTable 都能装进上限，则缓存大小必须受上限约束
+    const oversizedPinned = lsm.getOversizedCount();
+    if (oversizedPinned === 0) {
       expect(lsm.getCacheSize()).toBeLessThanOrEqual(lsm.getCacheLimit());
     }
 
     await engine.close();
   });
 
+  test('超大 SSTable 常驻缓存（驱逐会导致读取静默跳过整个文件）', async () => {
+    const engine = createSmallCacheEngine(1); // 4KB 上限，单个 SSTable 必然超过
+    await engine.open('cache-oversized-pin', 1);
+    await engine.createTable(createSchema('users', {
+      id: { type: 'string', primaryKey: true },
+      name: { type: 'string' },
+    }));
+    await engine.insert('users', makeRows(300));
+    const lsm = (engine as any).lsm as {
+      flush(): Promise<void>;
+      getCacheSize(): number;
+      getCacheLimit(): number;
+      getOversizedCount(): number;
+      trimCache(): void;
+      getStats(): { sstableCount: number };
+    };
+    await lsm.flush();
+    expect(lsm.getStats().sstableCount).toBeGreaterThan(0);
+
+    // 强制裁剪后，超大文件仍必须可读（数据完整）
+    lsm.trimCache();
+    expect(lsm.getOversizedCount()).toBeGreaterThan(0);
+    const all = await engine.find('users', { table: 'users' });
+    expect(all.length).toBe(300);
+    await engine.close();
+  });
+
   test('缓存驱逐后全表扫描仍返回完整数据（prefetch 兜底）', async () => {
     const engine = createSmallCacheEngine(1); // 4KB 上限，必然触发驱逐
     await engine.open('cache-evict-fullscan', 1);
@@ -78,11 +116,11 @@ describe('AriaEngine SSTable 缓存内存上限', () => {
     const rows = makeRows(300);
     await engine.insert('users', rows);
 
+    // v0.8.0: 这是最关键的数据完整性断言 —— 缓存上限极小（4KB）而 SSTable 更大时，
+    // 读取路径必须仍然返回**全部** 300 行（此前会静默少数据）。
     const all = await engine.find('users', { table: 'users' });
     expect(all.length).toBe(300);
 
-    const lsm = (engine as any).lsm;
-    expect(lsm.getCacheSize()).toBeLessThanOrEqual(lsm.getCacheLimit());
     await engine.close();
   });