React version: 18.3.0-next-3ba7add60-20221201

Hard to reproduce.

In Next.js, in rare cases, and only after a fast refresh, the ref object when using forwardRef is simply `{}`.

This leads to the `TypeError: can't define property "current": Object is not extensible` error when used with `useImperativeHandle`.

```tsx
function Parent() {
  const carouselRef = useRef<any>();

  return <Suspense><Carousel ref={carouselRef} /></Suspense>
}

const Carousel = forwardRef((props, ref) => {
  if (!('current' in ref)) { debugger; }
  const thing = use(aPromise);
  return ...;
});
```

![Screenshot 2023-03-17 at 18 49 21](https://user-images.githubusercontent.com/5406212/225981809-22f575fa-0ec7-4f94-ae23-bffc8bf7c4dd.png)

In `updateImperativeHandle`, the ref is already an empty object.

![Screenshot 2023-03-17 at 19 13 13](https://user-images.githubusercontent.com/5406212/225985622-b8512a61-3a6b-4958-b63f-277219d4c816.png)

I haven't investigated it further yet, the stacktraces are quite hard to follow.
if (hasUncaughtError) {
    hasUncaughtError = false;
    const error = firstUncaughtError;
    firstUncaughtError = null;
    throw error;
  }
   If the passive effects are the result of a discrete render, flush them
   synchronously at the end of the current task so that the result is
   immediately observable. Otherwise, we assume that they are not
   order-dependent and do not need to be observed by external systems, so we
   can wait until after paint.
   TODO: We can optimize this by not scheduling the callback earlier. Since we
   currently schedule the callback in multiple places, will wait until those
   are consolidated.
  if (includesSyncLane(pendingPassiveEffectsLanes) && root.tag !== LegacyRoot) {
    flushPassiveEffects();
  }
   Read this again, since a passive effect might have updated it
  remainingLanes = root.pendingLanes;
  if (includesSyncLane(remainingLanes)) {
    if (enableProfilerTimer && enableProfilerNestedUpdatePhase) {
      markNestedUpdateScheduled();
    }
     Count the number of times the root synchronously re-renders without
     finishing. If there are too many, it indicates an infinite update loop.
    if (root === rootWithNestedUpdates) {
      nestedUpdateCount++;
    } else {
      nestedUpdateCount = 0;
      rootWithNestedUpdates = root;