Specifically `An update to * inside a test was not wrapped in act(...)` is not logged when a prior update threw. 

<details>
<summary>failing test (#21766)</summary>

```js
// @gate __DEV__
it('warns if a setState is called outside of act(...) after a component threw', () => {
  let setValue = null;
  function App({defaultValue}) {
    if (defaultValue === undefined) {
      throw new Error();
    }
    const [value, _setValue] = React.useState(defaultValue);
    setValue = _setValue;
    return value;
  }

  expect(() => {
    act(() => {
      render(<App defaultValue={undefined} />, container);
    });
  }).toThrow();

  act(() => {
    rerender(<App defaultValue={0} />, container);
  });

  expect(() => setValue(1)).toErrorDev([
    'An update to App inside a test was not wrapped in act(...).',
  ]);
});
```
</details>

What I noticed is that in https://github.com/facebook/react/blob/27c9c95e23ddedb9163373950e364dd62038f6c0/packages/react-reconciler/src/ReactFiberWorkLoop.new.js#L2855-L2865
the `executionContext` will still equal `RetryAfterError` when we would expect a "missing act" warning.

"missing act" warnings are working as expected with legacy roots.
export const RetryAfterError =  0b1000;
type RootExitStatus = 0 | 1 | 2 | 3 | 4 | 5;
const RootIncomplete = 0;
const RootFatalErrored = 1;
const RootErrored = 2;
const RootSuspended = 3;
const RootSuspendedWithDelay = 4;
const RootCompleted = 5;
let executionContext: ExecutionContext = NoContext;
let workInProgressRoot: FiberRoot | null = null;
let workInProgress: Fiber | null = null;
let workInProgressRootRenderLanes: Lanes = NoLanes;
export let subtreeRenderLanes: Lanes = NoLanes;
const subtreeRenderLanesCursor: StackCursor<Lanes> = createCursor(NoLanes);
 Whether to root completed, errored, suspended, etc.
let workInProgressRootExitStatus: RootExitStatus = RootIncomplete;
 A fatal error, if one is thrown
let workInProgressRootFatalError: mixed = null;
 "Included" lanes refer to lanes that were worked on during this render. It's
 slightly different than `renderLanes` because `renderLanes` can change as you
 enter and exit an Offscreen tree. This value is the combination of all render
 lanes for the entire render phase.
let workInProgressRootIncludedLanes: Lanes = NoLanes;
 The work left over by components that were visited during this render. Only
 includes unprocessed updates, not work in bailed out children.
let workInProgressRootSkippedLanes: Lanes = NoLanes;
 Lanes that were updated (in an interleaved event) during this render.
let workInProgressRootUpdatedLanes: Lanes = NoLanes;
 Lanes that were pinged (in an interleaved event) during this render.
let workInProgressRootPingedLanes: Lanes = NoLanes;