add an option to report an error when `Symbol.dispose`/`Symbol.asyncDispose` objects are used without the `using` keyword

Nessuno ha ancora preso questa issue.

### 🔍 Search Terms

dispose using error

### ✅ 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 was surprised to learn that using disposables without the `using` keyword are not reported as an error:

```ts
const foo = {
[Symbol.dispose]: () => {
console.log("disposed"); // never called
},
};

{
const bar = foo;
console.log(bar);
}
```

### 📃 Motivating Example

[the documentation compares it to python `with` statements](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#:~:text=that%2E-,You,scope). but the whole point of context managers is to enforce that an object is always properly cleaned up. if you forget to use `with`, then the object's setup is never run so its cleanup doesn't need to run either.

since this is not the case with the `using` keyword, it should be a type error to use it in an unsafe way

### 💻 Use Cases

i have an API that i need to log out of when i'm finished using it, otherwise the session remains active

```ts
const login = () => {
// ...
return {
[Symbol.asyncDispose]: () => {
// important cleanup code that MUST be run no matter what
}
}
}
```

in python i would do this with a context manager, and i'd be confident that the cleanup code would always be executed. it's not up to the caller to remember to use the `with` statement. however in typescript, the caller could easily do this by mistake:

```ts
const sesion = await login()
// cleanup code never gets called
```

this is extremely surprising behavior coming from a language with a similar feature. is this is intentional, the docs should have a clear warning that `Symbol.dispose` and `Symbol.asyncDispose` functions have no guarantee to actually be called.

Non è indicato alcun file di implementazione né alcun test. Inizia dalla documentazione collegata delle note di rilascio di TypeScript 5.2 e dagli esempi sincroni e asincroni nell’issue, quindi determina il comportamento previsto della diagnostica e dell’opzione per gli oggetti disposable usati senza using. Il lavoro è completato quando l’uso improprio richiesto viene segnalato senza modificare il JavaScript emesso.

Scritto dal modello di indicizzazione a partire dal testo della issue.