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

Dieses Issue hat noch niemand übernommen.

### 🔍 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.

Es wird keine Implementierungsdatei und kein Test genannt. Beginne mit der verlinkten Dokumentation zu den TypeScript 5.2 Release Notes sowie den synchronen und asynchronen Beispielen im Issue und ermittle anschließend das beabsichtigte Diagnose- und Optionsverhalten für Disposable-Objekte, die ohne using verwendet werden. Die Aufgabe ist erledigt, wenn der angeforderte Missbrauch gemeldet wird, ohne das erzeugte JavaScript zu ändern.

Vom Indexierungsmodell aus dem Issue-Text verfasst.