refactor(core): pre-resolve child imports before V8 module registration

[bartlomieju]

When a child import returned ModuleResolveResponse::Async from the loader,
find_imports_in_compiled_module used to discard the future, place a
placeholder URL on the request with needs_resolve = true, and let
RecursiveModuleLoad issue a second resolve later. That doubled every async
resolve round-trip (the first reply was sent to a dropped oneshot::Receiver
and silently lost) and required the synth-placeholder fallback that was
necessary because base.join(spec) fails for cannot-be-a-base referrers
like blob: and data: — the original bug this PR was opened for: lume's
MDX plugin compiling MDX into a blob: module that imports
lume/jsx-runtime, plus the related vite/rollup case where any transitive
module.register() (e.g. tailwindcss) flipped on resolve_active and broke
node:path imports from inside npm packages.

The fix is to pre-resolve child imports before V8 registers the module.
new_module_from_js_source_with_pending compiles via V8 in scope, tries each
child resolve synchronously, and either:

• registers and returns NewModuleResult::Ready(id) — fast path when no
  async hooks are active, no behaviour change;
• stashes the resolve futures inside a PendingModule { handle, requests, pending_resolves, … } and returns Pending.

finalize_pending_module awaits the pending futures, patches the URLs into
the request list, and calls create_module_info. Single worker round-trip
per resolve. register_and_recurse now returns
RegisterOutcome::{Done, PendingFinalize}; both run_to_completion (main /
side loads) and drain_dyn_imports (dynamic imports via op_import) drop
the V8 scope on PendingFinalize, await finalize_pending_module, re-enter
scope, and call finalize_after_pending to register and recurse.

ModuleRequest.needs_resolve, the duplicate resolve_async at
recursive_load::register_and_recurse_inner line 495,
ModuleMap::resolve_async, and the synth-placeholder fallback are all gone
— subsumed by the new flow. Placeholder slots on PendingModule.requests
are never observed by anything downstream. Sync call sites (V8
module_resolve_callback, lazy_load_esm_module, do_load_job) keep using
new_module_from_js_source which now errors clearly if a synchronous
context ever encounters an async-resolve loader, instead of papering over it
with a placeholder.

Adds a spec test under
tests/specs/node/module_register_esm/blob_bare_specifier covering the
original lume case: a passthrough module.register() hook, a blob: module
importing a bare specifier resolved via the import map. The hook writes to
stderr when it sees the bare specifier from a blob: parent and the expected
output asserts on it, ruling out a silent bypass regression. The lume MDX
repro and the rollup-with-hooks node:path regression both pass.

Closes bartlomieju/orchid-inbox#57