Way to detect whether a callable has type parameters

### 🔍 Search Terms

conditional type detect callable type parameter

### ✅ Viability Checklist

- [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
- [x] This wouldn't change the runtime behavior of existing JavaScript code
- [x] This could be implemented without emitting different JS based on the types of the expressions
- [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
- [x] This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
- [x] This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

### ⭐ Suggestion

I'm looking for some way to detect if a callable type is generic and has type parameters.

LLMs are hallucinating an answer that would be nice if it worked:

```js
type HasTypeParameter any> =
T extends (...args: any[]) => any ? true : false;
```

### 📃 Motivating Example

I have a utility type that wants to map the return value of a callable. However because as far as I know it's not possible to map a type-parametrized callable keeping its parametrization, we prefer to bail out in this case and maintain the original type.

Roughly it looks like

```js
type MappedCallable = HasTypeParameter extends true
? T
: (...args: Parameters) => MappedResult>;
```

### 💻 Use Cases

I can achieve this detection in some case where the type of the callable is incompatible with a mapped callable were its type parameters inferred as `any`.

```js
type LimitedHasTypeArgument any> =
((...args: Parameters) => ReturnType) extends T ? false : true
```

However this doesn't work in some more complex cases (still trying to get a minimal repro).

I cannot think of other workarounds, which is forcing us to forego the result type mapping completely.

Of course having a way to keep the callable type-parametrization in the result mapping would be even better.

The specific use case is to map all callable in the result, including object methods, to callables returning a promise, while maintaining other parts of their signature.

L’issue ne nomme aucun fichier source, test ou point d’entrée de l’implémentation, et indique qu’une reproduction minimale est encore en cours de développement. Commencez par réduire les exemples de callables génériques à un test du compilateur ; le travail serait considéré comme terminé s’il existait un moyen fiable de détecter ou de préserver les paramètres de type callable, ou une résolution documentée.

Rédigé par le modèle d'indexation à partir du texte de l'issue.