Fix progressive performance degradation in playground.run()

[JanJakes]

Motivation for the change, related issues

Repeated calls to playground.run() exhibited progressive performance degradation. The first batch of calls would execute in ~1ms, but after many calls the execution time would increase to 10-11ms — an 11.76x slowdown.

This affected browser-based usage where the same PHP instance is reused across requests via SinglePHPInstanceManager.

Implementation details

Three sources of resource accumulation were identified and fixed:

1. Comlink proxy accumulation (comlink-sync.ts)

Each property access on a Comlink proxy created a new proxy object registered with FinalizationRegistry. These proxies accumulated over time. Fixed by adding a WeakMap-based cache that reuses existing proxies for the same endpoint and path combination.

2. Stream reader cleanup (php-response.ts)

The streamToText() and streamToBytes() functions didn't properly release reader locks in all code paths. Fixed by adding try/finally blocks with reader.releaseLock().

3. Worker listener accumulation (php-worker.ts)

When using SinglePHPInstanceManager, the same PHP instance is reused across multiple run() calls. Previously, registerWorkerListeners() added new event listeners on every call, causing O(n) listener accumulation where each event fired N times for N calls. Fixed by tracking registered instances in a WeakSet to prevent duplicate registration.

Testing Instructions (or ideally a Blueprint)

Run this in the browser console on the Playground website:

(async () => {
    const playground = window.playground;
    
    // Warmup
    for (let i = 0; i < 5; i++) {
        await playground.run({ code: '<?php echo "warmup";' });
    }
    
    const times = [];
    for (let i = 0; i < 100; i++) {
        const start = performance.now();
        await playground.run({ code: '<?php echo "test";' });
        times.push(performance.now() - start);
    }
    
    const avg = (arr) => arr.reduce((a, b) => a + b, 0) / arr.length;
    const first10 = avg(times.slice(0, 10));
    const last10 = avg(times.slice(-10));
    
    console.log('First 10 avg:', first10.toFixed(2) + 'ms');
    console.log('Last 10 avg:', last10.toFixed(2) + 'ms');
    console.log('Ratio:', (last10 / first10).toFixed(2) + 'x');
})();

Before: Ratio ~11.76x (gets slower)
After: Ratio ~0.7x (gets faster due to JIT — no degradation)