Add a `redeclare` keyword to redeclare class attributes, behaving like `override !:` while keeping type modifiers.

### 🔍 Search Terms

redeclare
declare override

Related issues:
- https://github.com/microsoft/typescript/issues/51515
- https://github.com/microsoft/typescript/issues/37771
- https://github.com/microsoft/TypeScript/issues/4062

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

A `redeclare` keyword behaving like `override` + `declare` while keeping previous type modifiers (e.g. `readonly`, `protected`, `public`).

```ts
type BaseType = {};
type Overriden = {x: number};

class A {
protected readonly foo: BaseType;

constructor(protected readonly faa: BaseType) {}
}

class B extends A {
redeclare foo: Overriden;
// equivalent to "override [protected readonly] foo!: Overriden"

constructor( redeclare faa: Overriden ) { super(faa); }
// idem above. Do not set faa itself.
}
```

We could use `redeclare` with modifiers, e.g. `public` or `-readonly` to override previous type modifiers:
```ts
redeclare public faa: Overriden; // make it public, do not change whether it is readonly or not, etc.
redeclare public faa; // make it public, do not change its type, whether it is readonly or not, etc.
redeclare -readonly faa; // make it read-write, do not change its type or its visibility.
```

I also suggest the related changes:
- in constructor parameters, `!:` would mean "declare but do not set".
- using `declare` as an alias to `!:` when used in constructor parameters, or with `override`.

Note: `redeclare` could also be used in other contexts, e.g. to precise a variable type (cf related issue), but this is not in the scope of this suggestion.

### 📃 Motivating Example

Currently, if you want to override an attribute, you have to:
```ts
type BaseType = {};
type Overriden = {x: number};

class A {
protected readonly foo: BaseType;
}

class B extends A {
override readonly foo!: Overriden;
}
```

However, if you forget one of the type modifier (here: `protected`) you would have no warnings as it might be voluntary. A reader do not know if this is a mistake or not.

By using `redeclare` you would ensure no type modifier is forgotten, while making intents explicit.
Indeed, if the type modifiers are modified in class `A`, using `redeclare` ensures that all subclasses has the correct type modifiers (except if explicitly stated otherwise).

Also, `redeclare` would enable to redeclare a type from the constructor, instead of having to provide the type twice.
```ts
type BaseType = {};
type Overriden = {x: number};

class A {
protected readonly foo: BaseType;
}

class B extends A {
constructor( redeclare foo: Overriden ) { ... }
}
```

### 💻 Use Cases

1. What do you want to use this for?

Safely re-declaring classes attributes.

3. What shortcomings exist with current approaches?

- We have to rewrite all type modifiers.
- In constructors parameters, we would have useless (or even unwanted) attribute assignations.
- Without constructors parameters, requires to provide the type twice.
- With a generic base class, this is quite brittle : the base class and each of its subclasses needs to know which of the attribute might be redeclared. This could lead too an excessive amount of generic types if too much attributes.

4. What workarounds are you using in the meantime?

I use constructors parameters with the useless assignations.

首先阅读相关 issue #51515、#37771 和 #4062，以及重新声明示例和可行性检查清单。明确类属性和构造函数参数的拟议行为，包括继承的修饰符和显式覆盖；要视为完成，需要一份达成共识的语言设计，而该 issue 目前尚未提供这一设计。

由索引模型根据 Issue 内容生成。