Nested `startTransition` call "takes over" and makes parent `startTransition` unable to track `isPending`.

Seb says it's a bug.

Repro:

https://codesandbox.io/s/pensive-breeze-rg70wn?file=/IndexPage.js:192-288

1. Click the button
2. `isPending` in `IndexPage.js` is `true`

However, `isPending` in `App.js` is `false`.

Expected: `isPending` in `App.js` is also `true`.
We will invoke the entire component function twice. However, during the
   second invocation of the component, the hook state from the first
   invocation will be reused. That means things like `useMemo` functions won't
   run again, because the deps will match and the memoized result will
   be reused.
  
   We want memoized functions to run twice, too, so account for this, user
   functions are double invoked during the *first* invocation of the component
   function, and are *not* double invoked during the second incovation:
  
   - First execution of component function: user functions are double invoked
   - Second execution of component function (in Strict Mode, during
     development): user functions are not double invoked.
  
   This is intentional for a few reasons; most importantly, it's because of
   how `use` works when something suspends: it reuses the promise that was
   passed during the first attempt. This is itself a form of memoization.
   We need to be able to memoize the reactive inputs to the `use` call using
   a hook (i.e. `useMemo`), which means, the reactive inputs to `use` must
   come from the same component invocation as the output.
  
   There are plenty of tests to ensure this behavior is correct.
  const shouldDoubleRenderDEV =
    __DEV__ &&
    debugRenderPhaseSideEffectsForStrictMode &&
    (workInProgress.mode & StrictLegacyMode) !== NoMode;
  shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
  let children = Component(props, secondArg);
  shouldDoubleInvokeUserFnsInHooksDEV = false;
   Check if there was a render phase update