A normal Map doesn't satisfy the conditions for KeyValueCache
### Issue Description

The type definition for KeyValueCache:
```typescript
export interface KeyValueCache<V = string> {
  get(key: string): Promise<V | undefined>;
  set(key: string, value: V, options?: KeyValueCacheSetOptions): Promise<void>;
  delete(key: string): Promise<boolean | void>;
}
```

Are all implemented in the JS `Map` object but a Map doesn't satisfy the requirements for a KV-Cache since a map does not return promises.

For instance:

```typescript
const cacheMap = new Map(Object.entries(persistedDocuments));

export const graphql_server = new ApolloServer({
  schema,
  persistedQueries: {
    
    /*
     * There is a typescript error on the following line because:
     * TS2322: Type Map<string, string> is not assignable to type KeyValueCache<string>
     * The types returned by get(...) are incompatible between these types.
     * Type string | undefined is not assignable to type Promise<string | undefined>
    */
    cache: cacheMap,
  },
});
```

However if the map is wrapped in an like so:
```typescript
const KVC: KeyValueCache<string> = {
  async get(key: string) {
    return cacheMap.get(key);
  },
  async set(key: string, value: string) {
    cacheMap.set(key, value);
  },
  async delete(key: string) {
    return cacheMap.delete(key);
  },
};
```

then typescript will accept it as a valid KeyValueCache. 

We should allow for the KeyValueCache to return non-promise values. Is there any reason against it / anything it would break in the code? Otherwise I think it might be appropriate for me to create a pull request doing so.

### Link to Reproduction

See Above:

### Reproduction Steps

_No response_