In a custom hook, I forgot to wrap my `setState` call in a `useEffect`, which did not pose any problems prior to React 18 but now this does not work anymore. The component does not re-render if the store is changed back to its initial value. I guess this might be expected, but there was no warning whatsoever, so it was hard to find out.

So this is more like a question:
- Is that behavior a bug?
- If it is not, would it be useful to have a warning for another developer making the same mistake?

React version: 18
## Steps To Reproduce

1. Have a component use `useSyncExternalStore` (for example redux 8)
2. Call `setState` outside of `useEffect` or event handlers (in render)
3. Trigger a change to the store back and forth

Link to code example: https://codesandbox.io/s/react-18-redux-8-reproduce-bug-ojdx43

## The current behavior

- The component does re-render if the store value is updated to something different than its initial value
- The component **does not** re-render if the store is updated to its initial value again

## The expected behavior

- The component does re-render if the store value is updated to something different than its initial value
- The component **also does** re-render if the store is updated to its initial value again

## Further digging

When I tried to trace down the issue, I found that the `setState` called outside `useEffect` would mess up with the fiber update queue, in particular the prior `pushEffect` supposedly calling `updateStoreInstance` with the latest value to have the internal cached instance up to date. It does not get called at all (cancelled? overridden?) because of the unwrapped `setState`.

As a consequence, that cached instance never gets updated. Any other value but the initial value hence correctly triggers a re-render, as the `checkIfSnapshotChanged` ends up always comparing against that initial value. 
}
  } else {
    ReactCurrentDispatcher.current =
      current === null || current.memoizedState === null
        ? HooksDispatcherOnMount
        : HooksDispatcherOnUpdate;
  }
   If this is a replay, restore the thenable state from the previous attempt.
  const prevThenableState = getSuspendedThenableState();
  prepareThenableState(prevThenableState);
   In Strict Mode, during development, user functions are double invoked to
   help detect side effects. The logic for how this is implemented for in
   hook components is a bit complex so let's break it down.
  
   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