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

まだ誰も着手していません。

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

実装ファイルもテストも指定されていません。リンク先の TypeScript 5.2 release-notes ドキュメントと、issue 内の同期および非同期の例から始め、using を使わずに使用された disposable オブジェクトに対して意図された診断とオプションの動作を判断してください。要求された誤用が報告され、出力される JavaScript が変更されなければ完了です。

索引モデルが issue の本文から書いたものです。