feat: Allow concurrent world state access

[PhilWindle]

Implements per-fork queues for requests to the native world state following it's concurrency rules. Also tightens up aspects of the cached store to ensure reads of committed data don't access anything uncommitted.

1. Reads of committed state never need to be queued. LMDB uses MVCC to ensure readers see a consistent view of the DB.
2. Reads of uncommitted state can happen concurrently with other reads of uncommitted state on the same fork (or reads of committed state)
3. All writes require exclusive access to their respective fork

[github-actions]

Changes to circuit sizes

Generated at commit: 41e8a878c8f540cd6529c44b0cd85a8b4ed2e259, compared to commit: dfb0db572868896bea27a13606da2a7e3c10f31e

🧾 Summary (100% most significant diffs)

Program	ACIR opcodes (+/-)	%	Circuit size (+/-)	%
rollup_base_private	+49 ❌	+0.04%	+60 ❌	+0.00%
rollup_base_public	+56 ❌	+0.02%	+67 ❌	+0.00%

---

Full diff report 👇

Program	ACIR opcodes (+/-)	%	Circuit size (+/-)	%
rollup_base_private	138,590 (+49)	+0.04%	1,772,615 (+60)	+0.00%
rollup_base_public	366,997 (+56)	+0.02%	3,236,019 (+67)	+0.00%

[alexghr]

LGTM. Just a question on queue draining. Everything is else is minor

[alexghr]

IIRC mockBlock modified the fork parameter with the block info (in order to create the correct block header).

Writing the same block data to the same fork inserts empty leaves into the public data tree so the sibling path will still change. The test is still correct but we might want to use two different forks: one for building the blocks and the other to test the writes.

[PhilWindle]

Oh thats was stupid. The test should be using a different fork!

[alexghr]

Was going to suggest using shfit here but not all branches of the if statemnent remove the head of the list

[alexghr]

This can be simplified slightly

Suggested change

	op.request()
	.then(resp => {
	op.promise.resolve(resp);
	this.ops.delete(op.requestId);
	})
	.catch(err => {
	op.promise.reject(err);
	this.ops.delete(op.requestId);
	});
	op.request().then(op.promise.resolve, op.promise.reject)
	.finally(() => {
	this.ops.delete(op.requestId);
	})

[alexghr]

Same as above. If the ops.delete was moved inside checkAndEnqueue it could be even cleaner I think

Suggested change

	op.request()
	.then(resp => {
	op.promise.resolve(resp);
	this.checkAndEnqueue(op);
	this.ops.delete(op.requestId);
	})
	.catch(err => {
	op.promise.reject(err);
	this.checkAndEnqueue(op);
	this.ops.delete(op.requestId);
	});
	op.request().then(op.promise.resolve, op.promise.reject)
	.finally(resp => {
	this.checkAndEnqueue(op);
	this.ops.delete(op.requestId);
	})