React version: 18.2.0
Next version: 13.1.1

## Steps To Reproduce

1. Suspend using a (fake) promise in a client component in app dir (next)
2. Try to useState after the use() call

````ts
'use client';

import { use, useState } from 'react';

const testPromise = new Promise((resolve) => {
  setTimeout(() => {
    resolve('use test promise');
  });
});

export default function Page() {
  use(testPromise);
  useState(0);

  return <h1>Test</h1>;
}

````

Link to code example:
https://codesandbox.io/s/github/xiel/app-playground/tree/suspense-error/?from-embed=&file=/app/page.tsx

## The current behavior

Suspending for a promise in a client component and using state/reducer after results in errors during hydration:

```
react-dom.development.js?9d87:94 Warning: An error occurred during hydration. The server HTML was replaced with client 

react-dom.development.js?9d87:94 Warning: You are accessing "digest" from the errorInfo object passed to onRecoverableError. 

on-recoverable-error.js?eb92:17 Uncaught Error: Should have a queue. This is likely a bug in React. Please file an issue.
```

## The expected behavior

No error during hydration.

ReactCurrentDispatcher.current = HooksDispatcherOnUpdateInDEV;
    } else if (hookTypesDev !== null) {
      
      
      
      
      
      ReactCurrentDispatcher.current = HooksDispatcherOnMountWithHookTypesInDEV;
    } else {
      ReactCurrentDispatcher.current = HooksDispatcherOnMountInDEV;
    }
  } else {
    ReactCurrentDispatcher.current =
      current === null || current.memoizedState === null
        ? HooksDispatcherOnMount
        : HooksDispatcherOnUpdate;
  }
   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: