fix(sqlite): stop SqliteAiVectorStorage.putBulk deadlocking on its own chain slot

`guardedWrite` (added with withConnectionTransaction) routes every public
write through `runOnConnection`, but `SqliteAiVectorStorage._putBulkInternal`
had taken the shared connection-chain slot itself since before anything above
it did. `putBulk` therefore took the slot twice on one handle: the inner
`runOnConnection` awaits the outer's promise, which only resolves once the
inner returns.

The `finally` never runs, so `state.chain` is left unresolved and the handle
is poisoned for every later write on it — which is why the suite's `afterEach`
`deleteAll()` timed out alongside the three `putBulk` tests.

The parent `SqliteTabularStorage._putBulkInternal` does not re-take the chain;
this restores that symmetry. Both entry paths already hold the slot: the public
`putBulk` via `guardedWrite`, and a call arriving through the `tx` proxy runs
inside the transaction that holds it — which is why the removed branch was
reachable only from the deadlocking path. `runVectorPutBulkOnHandle` still
reads `db.inTransaction` to decide whether to open its own `db.transaction`,
so SQLite transaction nesting is unchanged.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: sroussey

providers/sqlite/src/storage/SqliteAiVectorStorage.ts

@@ -17,7 +17,6 @@ import {
   getMetadataProperty,
   getVectorProperty,
   matchesFilter,
-  runOnConnection,
   validateVectorEntities,
 } from "@workglow/storage";
 import type {
@@ -487,17 +486,10 @@ export class SqliteAiVectorStorage<
       return super._putBulkInternal(entities);
     }
 
-    // Route the vector-encoding write through the shared connection chain so
-    // two SqliteAiVectorStorage instances that wrap the same underlying handle
-    // (or one vector storage and one plain SqliteTabularStorage) queue on the
-    // same lock instead of racing on the shared connection. Skip when we are
-    // already inside an outer `withTransaction` — the chain lock is held there.
-    const dbWithFlag = this.database as unknown as { readonly inTransaction?: boolean };
-    const alreadyInTx = this.inTransaction || dbWithFlag.inTransaction === true;
-    const handle = this.connectionHandle();
-    if (handle !== null && !alreadyInTx) {
-      return runOnConnection(handle, this, () => this.runVectorPutBulkOnHandle(entities));
-    }
+    // The shared connection chain slot is already held by whoever reached
+    // here: the public `putBulk` takes it in `guardedWrite`, and a call
+    // arriving through the `tx` proxy runs inside the transaction that holds
+    // it. Re-taking it here would await a slot only this call can release.
     return this.runVectorPutBulkOnHandle(entities);
   }