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.

No implementation file or test is named. Start with the linked TypeScript 5.2 release-notes documentation and the synchronous and asynchronous examples in the issue, then determine the intended diagnostic and option behavior for disposable objects used without using. Done means the requested misuse is reported without changing emitted JavaScript.

Written by the indexing model from the issue text.