Deprioritise properties of the form `{ prop?: never }` in completions

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

### 🔍 Search Terms

exact union properties, autocomplete prioritisation, completion prioritisation, `never` properties

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

It'd be nice if properties of the form `{ prop?: never }` were deprioritised in autocomplete. For example in this snippet:
```ts
const data: { a?: never; b: string } = { b: "foo" };
```

If you write `data.` you'll immediately get suggested `a` and then `b` but the property `a` may as well be useless in practice.

Similarly properties of the form `{ prop?: undefined }`, `{ prop: undefined }`, and `{ prop: never }` _could_ also be deprioritised. `{ prop?: undefined }` makes sense for better support for `"exactOptionalPropertyTypes": false` and the required variants are simply for consistency.

### 📃 Motivating Example

TypeScript assumes all objects can have excess keys. That can be a source of common confusion when snippets like this doesn't work:
```ts
function getData(): { a: string } | { b: string } {
return { a: "foo" };
}

getData().a;
// ^ Property 'a' does not exist on type '{ a: string; } | { b: string; }'.
// Property 'a' does not exist on type '{ b: string; }'.
```

Users generally expect this to simply be typed as `string | undefined`. A common pattern for overcoming this is adding properties like `{ b?: never }`. So common, in fact, that TypeScript itself produces it:
```ts
const data = Math.random() > 0.5 ? { a: "foo" } : { b: "bar" };
// ^ { a: string; b?: never } | { b: string; a?: never }
```
(if you see `b?: undefined` and `a?: undefined` that's because you don't have `exactOptionalPropertyTypes` enabled).

However the property completions are worsened due to this.
```ts
const data = Math.random() > 0.5 ? { a: "foo" } : { b: "bar" };

if (data.b === "foo") {
// `data` has been narrowed due to the above condition being impossible for `{ a: string; b?: never }`
data;
// ^ `{ a?: never; b: string }`

data.
// ^ `a` is suggested first despite being a completely useless property.
}
```

### 💻 Use Cases

1. What do you want to use this for?
Narrowed unions with `never` properties.
2. What shortcomings exist with current approaches?
Poor completion ordering.
3. What workarounds are you using in the meantime?
No workarounds are possible today as far as I know because the only control a user has over completion ordering is a property name.

issue にある `data.` の補完例を、絞り込まれたユニオンと `exactOptionalPropertyTypes` の各バリエーションを含めて再現してください。`never` または `undefined` として型付けされたプロパティについて、補完の優先順位付けの経路を追跡し、それらのプロパティが型チェックや生成される JavaScript を変更せずに一貫して優先度を下げられるようになった時点で作業完了とします。

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