Add allowImportingJsExtensions option to prevent incorrect .js imports

Nobody has claimed this yet.

### 🔍 Search Terms

moduleResolution nodenext, import js extension, prevent .js imports, strict module resolution

### ✅ 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

Introduce a new compiler option:

```json
"allowImportingJsExtensions": false
```

When set to `false`, TypeScript should prevent importing `.js` extensions unless the corresponding `.js` file physically exists.

Currently, in projects using `"moduleResolution": "nodenext"`, TypeScript allows importing `.js` extensions even when there is no actual `.js` file, leading to confusion and incorrect imports in TypeScript-only projects.

### 📃 Motivating Example

Consider a TypeScript project using `"moduleResolution": "nodenext"`:

```ts
import { something } from "./utils.js"; // Allowed, but utils.js does not exist
```

Here, TypeScript does not raise an error even though `utils.js` is not present. This can cause issues in projects that exclusively use `.ts` files and never generate `.js` files manually.

With the proposed option:

```json
"allowImportingJsExtensions": false
```

The above import would result in a TypeScript error unless `utils.js` is physically present.

### 💻 Use Cases

1. **Prevent incorrect imports in TypeScript-only projects**: This option helps ensure `.js` imports are only allowed when the actual file exists, reducing accidental misconfigurations.
2. **Stricter enforcement of module resolution**: This aligns with `"moduleResolution": "nodenext"`, enforcing explicit file extensions while avoiding implicit assumptions.
3. **Avoid runtime errors**: Developers may assume a `.js` file exists due to TypeScript allowing the import, only to discover at runtime that the file is missing. This feature prevents such issues at compile time.
4. **Current workaround is manual**: The only way to enforce this today is by manually checking the filesystem or using linting rules, which is not ideal.

Start by reviewing how compiler options are defined and how moduleResolution nodenext resolves .js imports. Determine the intended behavior for missing and existing .js files, then add focused coverage for the proposed option. Done means the option is documented, validated, and its behavior is covered by tests.

Written by the indexing model from the issue text.