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.
The most recent time we committed a fallback. This lets us ensure a train
 model where we don't commit new loading states in too quick succession.
let globalMostRecentFallbackTime: number = 0;
const FALLBACK_THROTTLE_MS: number = 500;
 The absolute time for when we should start giving up on rendering
 more and prefer CPU suspense heuristics instead.
let workInProgressRootRenderTargetTime: number = Infinity;
 How long a render is supposed to take before we start following CPU
 suspense heuristics and opt out of rendering more content.
const RENDER_TIMEOUT_MS = 500;
function resetRenderTimer() {
  workInProgressRootRenderTargetTime = now() + RENDER_TIMEOUT_MS;
}
export function getRenderTargetTime(): number {
  return workInProgressRootRenderTargetTime;
}
let hasUncaughtError = false;
let firstUncaughtError = null;
let legacyErrorBoundariesThatAlreadyFailed: Set<mixed> | null = null;
 Only used when enableProfilerNestedUpdateScheduledHook is true;
 to track which root is currently committing layout effects.
let rootCommittingMutationOrLayoutEffects: FiberRoot | null = null;
let rootDoesHavePassiveEffects: boolean = false;
let rootWithPendingPassiveEffects: FiberRoot | null = null;
let pendingPassiveEffectsLanes: Lanes = NoLanes;
let pendingPassiveProfilerEffects: Array<Fiber> = [];
 Use these to prevent an infinite loop of nested updates
const NESTED_UPDATE_LIMIT = 50;
let nestedUpdateCount: number = 0;
let rootWithNestedUpdates: FiberRoot | null = null;