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.
Use this function to schedule a task for a root. There's only one task per
 root; if a task was already scheduled, we'll check to make sure the priority
 of the existing task is the same as the priority of the next level that the
 root has work on. This function is called on every update, and right before
 exiting a task.
function ensureRootIsScheduled(root: FiberRoot, currentTime: number) {
  const existingCallbackNode = root.callbackNode;
   
   
  markStarvedLanesAsExpired(root, currentTime);
   
  const nextLanes = getNextLanes(
    root,
    root === workInProgressRoot ? workInProgressRootRenderLanes : NoLanes,
  );
  if (nextLanes === NoLanes) {
     
    if (existingCallbackNode !== null) {
      cancelCallback(existingCallbackNode);
    }
    root.callbackNode = null;
    root.callbackPriority = NoLane;
    return;
  }
   
  const newCallbackPriority = getHighestPriorityLane(nextLanes);
   
  const existingCallbackPriority = root.callbackPriority;
  if (
    existingCallbackPriority === newCallbackPriority &&