Syntax is the same as a normal parameter:

```ts
function f(this: void, x: number) {
}
```

If `this` is not provided, it defaults to `void` for functions and `this`
for methods. The rules for checking are similar to parameter checking, but
there's still quite a bit of duplication for this implementation.

The new overloads use this types to specify the return type of these
functions as well as the type of `thisArg`.

1. Display of `this` changes for quick info.
2. The type of Function.call/apply/bind is more precise.

Also fix other lint.

Only major thing is a bug fix in
`isContextSensitiveFunctionLikeDeclaration`, and turning on context
sensitivity to `this` even with `--strictThis` off.

Also remove lint in checker.

1. Add `getThisArgumentOfCall` (and correct the code)
2. Remove `getParameterTypeAtIndex` in favour of `getTypeAtPosition`.
Simplify calling code.

Now the language service also sees the contextual type.

Note that with this change, the type display for contextually typed this
parameters goes away because there is no symbol. I'll fix type display
next.

1. Always display `this` type if annotated.
2. Contextually type un-annotated `this` parameters in addition to `this`
expressions.

1. Fix bug in error reporting in compareSignaturesRelated.
2. When the this-argument is a union type, allow assignability when the
method's signature is assignable to *any* member of the union.

The right solution is to not instantiate this-types of unions, which is a
separate problem more to do with this-class types.

I added the temp test by mistake.

And and tests and baselines

Add a test and baseline

Use the upcoming naming scheme for --strict.*Checks and --strictChecks
flags.

It's basically another --noImplicitAny error, but one that would break
large amount of JavaScript-style code.

Previously it was only an error inside an function.

Previously, functions that specified a type for `this` would return that
type. Now they return `any`. This helps prevent unintentional use of this
feature when --noImplicitAny is turned on.

The type of `this` is still checked in the body of these functions.

Based on feedback from @DanielRosenwasser @Arnavion and @RichiCoder1