Update v8 to include Promise Context Tagging patch

[jasnell]

Implements a mechanism in v8 that allows tagging a Promise with a creation context, then using that to implement cross-request promise awaits.

The way the mechanism works is fairly straightforward:

1. Whenever we enter IoContext::Scope, we'll set a "promise context tag" on the Isolate, currently this is just an opaque empty object that we use only as a marker.
2. Whenever a JS Promise is created while we are in that IoContext::Scope, the Promise will be tagged with that same promise context tag object. When a JS Promise is created outside of the IoContext::Scope, its context tag is empty.
3. Whenever a JS Promise is followed (e.g. using await or by calling then, etc) the context tag on the promise is compared against the isolate's current context tag. If they are the same, or if the JS Promise's context tag is empty (meaning it was created outside of an IoContext) then nothing changes and we attach the continuation to THAT JS Promise. However, if the tags are different, that implies that we are following a JS Promise from one IoContext from a different IoContext and so our new PromiseCrossContextCallback is invoked.
4. The PromiseCrossContextCallback creates a CrossThreadWaitList and associates that with the JS Promise being followed. We attached continuations to that JS Promise that will fulfill or reject the CrossThreadWaitList.
5. A new JS Promise within the following IoContext is created and is set up to follow the CrossThreadWaitList. This new JS Promise replaces the promise that is being followed, and our then/await continuations are attached to this new Promise instead.

There are plenty of edge cases to work through to ensure that things are working but the fundamental idea appears to work with very little performance impact. I'll tag you both once I have the relevant PRs open.

The simple test case that I have been using to test that things work is simply:

export default {
  async fetch() {
    globalThis.promise ??= (async () => {
      console.log('fetching...');
      const resp = await fetch('https://example.com');
      return await resp.text();
    })();
    const text = await globalThis.promise;
    return new Response(`ok ${text.length}`);
  }
}

Then using simply curl localhost:8080 & curl localhost:8080 to queue up simultaneous requests should be enough to verify that it basically works. I was using autocannon to throw more concurrent load to test that things work with gc. If all goes well, every request should be handled successfully and the fetch should only ever happen once.

[jasnell]

Note: The PR still needs tests added to ensure it's working correctly. I'll likely add the tests to the internal PR since it'll be easier.

[ohodson]

V8 would typically use DISALLOW_IMPLICIT_CONSTRUCTORS(PromiseContextScope) for all but the move constructor here (not fanaticially used everywhere, jfyi).

[ohodson]

Overall this patch LGTM. I've run v8 tests against the new patch 0012 for release and debug builds with no issues.

[ohodson]

LGTM, but probably best to have approval from Kenton for greater familiarity with most of the parts here.

[kentonv]

Is there any performance impact for workers that don't use this?

Can we write a test case? I think the easiest way to do this would be to set up a test worker with a service binding (perhaps to an alternate entrypoint of itself). The test can then initiate multiple subrequests to the service binding and on the receiving end verify that they can synchronize with each other.

[jasnell]

Internal PR updated with a test.

[kentonv]

I don't understand the V8 code so will trust @ohodson's review there.