### Elasticsearch Version

8.6.0-SNAPSHOT

### Installed Plugins

_No response_

### Java Version

_bundled_

### OS Version

N/A

### Problem Description

We see 8.6.0 master nodes (512MB heap) repeatedly dying with OOME when attempting to do a snapshot with GCS snapshot repository. This is not reproducible with prior versions and we suspect that this is caused by https://github.com/elastic/elasticsearch/pull/90282.

### Steps to Reproduce

1. Start a cluster in a containerized environment; master nodes have 1GB of memory, 512MB of heap
2. Setup a GCS snapshot repository
3. Create a snapshot of the cluster.
4. The master node will OOM with the following message:

```
[5383.050s][warning][gc,alloc] elasticsearch[i6][snapshot][T#26]: Retried waiting for GCLocker too often allocating 256 words
[5383.053s][warning][gc,alloc] elasticsearch[i6][snapshot][T#14]: Retried waiting for GCLocker too often allocating 1029 words
java.lang.OutOfMemoryError: Java heap space
```

### Logs (if relevant)

_No response_
server/src/main/java/org/elasticsearch/threadpool/ThreadPool.java
* that this method is more expensive: the return value is computed directly from {@link System#nanoTime} and is not cached. You should
     * use {@link #relativeTimeInMillis()} unless the extra accuracy offered by this method is worth the costs.
     *
     * When computing a time interval by comparing relative times in milliseconds, you should make sure that both endpoints use cached
     * values returned from {@link #relativeTimeInMillis()} or that they both use raw values returned from this method. It doesn't really
     * make sense to compare a raw value to a cached value, even if in practice the result of such a comparison will be approximately
     * sensible.
     */
    public long rawRelativeTimeInMillis() {
        return TimeValue.nsecToMSec(System.nanoTime());
    }
    /**
     * Returns the value of milliseconds since UNIX epoch.
     *
     * This method should only be used for exact date/time formatting. For calculating
     * time deltas that should not suffer from negative deltas, which are possible with
     * this method, see {@link #relativeTimeInMillis()}.
     */
    public long absoluteTimeInMillis() {
        return cachedTimeThread.absoluteTimeInMillis();
    }
    @Override
    public ThreadPoolInfo info() {
        return threadPoolInfo;
    }
    public Info info(String name) {
        ExecutorHolder holder = executors.get(name);
        if (holder == null) {
            return null;
        }