fix(effect): handle synchronous re-entrancy in Effect.cached* - #8977

Problem

Found while upgrading a large app to Effect 4.0.1.

In makeCachedUnsafe (shared by Effect.cached, Effect.cachedWithTTL, and Effect.cachedInvalidateWithTTL), a cache miss publishes current = run with run.fiber = undefined and then calls run.fiber = forkUnsafe(fiber, ..., true, true). Because immediate is true, forkUnsafe evaluates the cached effect synchronously before returning the new fiber.

If that synchronous evaluation wakes another fiber that immediately evaluates the same cached effect before forkUnsafe returns (for example, completing a Deferred whose waiter runs a scope finalizer that calls the cached effect), the second fiber sees current !== undefined and calls join(fiber, current) while run.fiber is still undefined:

1. fiberJoin(run.fiber!) throws TypeError: Cannot read properties of undefined (reading '_exit').
2. When the second fiber unwinds, its onExitUnsafe handler decrements run.awaiters from 1 to 0 (because the initiating caller only increments run.awaiters after forkUnsafe returns), clears current = undefined, and calls fiberInterrupt(undefined).
3. fiberInterruptAs is dual and checks hasProperty(args[0], FiberTypeId), so passing undefined returns a curried function instead of an Effect, which fails the run loop with:

Unknown Error: Fiber.runLoop: Not a valid effect: (self) => body(self, ...arguments)

Minimal reproduction:

const gate = yield* Deferred.make<void>()
const cached = yield* Effect.cached(
  Effect.gen(function*() {
    yield* Deferred.succeed(gate, void 0)
    return 42
  })
)

const waiter = yield* Deferred.await(gate).pipe(
  Effect.andThen(cached),
  Effect.forkChild({ startImmediately: true })
)

yield* cached
yield* Fiber.join(waiter)

Fix

• Construct run.fiber = new FiberImpl(fiber.context) on CachedRun before publishing current = run and calling run.fiber.evaluate(...), so run.fiber is always defined when a re-entrant caller joins or interrupts it.
• Initialize run.awaiters to 1 for the initiating caller and increment current.awaiters when subsequent callers join, so a re-entrant waiter that joins and is interrupted during synchronous startup cannot drop run.awaiters to 0 and abandon the run while evaluate is still on the stack.
• If the cached computation re-enters the cached effect on its own fiber (fiber === current.fiber), return fiberJoin(current.fiber) without incrementing current.awaiters or registering an abandonment finalizer. A direct self-call suspends on self-join instead of crashing, and interrupting all external callers still drops run.awaiters to 0 and interrupts run.fiber.

Alternatives

1. Schedule the cached fiber with immediate = false (forkUnsafe(fiber, ..., false, true)). This would assign run.fiber and register the first caller before the cached body runs a single step, eliminating synchronous re-entrancy during startup. However, it gives up synchronous evaluation on cache misses: run.fiber._exit would never be populated synchronously, every first call would suspend until the scheduler flushes, and callers relying on synchronous startup effects (such as Effect.forkChild(cached, { startImmediately: true })) would observe different ordering.
2. Back CachedRun with a Deferred or Latch (similar to ScopedCache). Waiting on a Deferred avoids reading run.fiber in join, but it allocates an extra coordination object per cache miss and still requires run.fiber to be defined if a re-entrant waiter is interrupted during synchronous startup.
3. Broader follow-up across Cache, RcRef, and ResourceMap. RcRef and ResourceMap also publish an in-flight state with fiber: undefined as any before Effect.runForkWith evaluates the acquire/lookup effect synchronously, and Cache.get runs new EntryImpl (which calls forkUnsafe(..., true, true)) before inserting the entry into self.map. Keeping this PR scoped to makeCachedUnsafe keeps the fix minimal, and the same pre-allocated fiber pattern can be applied to those modules if desired.

Tests

pnpm test --run packages/effect/test/Effect.test.ts -t "cached"
pnpm test --run packages/effect/test/Effect.test.ts
pnpm test --run packages/effect/test/Cache.test.ts
pnpm lint
pnpm check

Closes EFF-1910