In Javascript, the compiler unions the type of all special-property-assignments to determine the type of properties declared this way. For example:

function C () { }
C.prototype.m1 = function() { this.a = 1 }
C.prototype.m2 = function() { this.a = 'hi' }

This results in C having an instance property a: string | number | undefined. However, when there's a this-assignment in the constructor, it should be treated as the definitive declaration:

function C() {
  this.a = 1
}
C.prototype.m1 = function() {
  this.a = 'hi' // error: 'string' is not assignable to 'number'
}

Assignment in the constructor is the most common Javascript pattern for declaring instance variables. This PR therefore implements 2 things:

1. Prefer this-assignments in the constructor to determine the type of special assignment declarations.
2. Initializers of type null, undefined and never[] become any, any and any[] respectively. This applies to all initializers, not just special-assignment initializers.

Specifically, when constructing the type for a special-assignment property, if there are this-assignments in the constructor, the types of those this-assignments are used in exclusion of other special-assignments. If, however, these types consist only of null | undefined, then all special-assignments are used to construct the type. For example:

function C() {
  this.ctor = 1
  this.ctor = 'hi'
  this.n = null
  this.empty = [] // no other assignments: this.empty: any[]
  this.useless = undefined
}
function C.prototype.m1() {
  this.ctor = false // error: this.ctor: string | number
  this.n = 1 // ok: this.n: number | null
  this.method = 1
  this.method = 'hi' // ok: this.method: string | number | undefined
  this.useless = null // ok, but this.useless: any
}

Note that

1. Properties whose this-assignments only appear in methods add undefined to the type since they may not be initialised during construction.
2. Properties that are assigned nothing but null and undefined will become any and properties that are assigned nothing but [] will become any[].

Fixes #22792
Fixes #22458

I tested this change on the user code in Javascript and it doesn't add any errors that I noticed. I believe this change will provide strictly better typing since the this-assignment-in-constructor pattern is so common in Javascript.