Improve incremental parsing by making algorithm less conservative about which nodes can be reused.

Previously we wouldn't reuse a node from a previous tree if it contained a keyword which had been
converted to an identifier.  i.e. if you had:

    private Foo() {
        this.public = a;
    }

Here 'public' was returned as a keyword from the scanner, but converted to an identifier by the
parser.  We marked the entire method as being non-reusable because we didn't want the the
incremental parser returning anything that the scanner wouldn't return.  however, this was somewhat
non-sensical.  The scanner doesn't return nodes in the first place.  So, if we're trying to reuse
a node, the presense of subnodes whihc are parser generated is fine.

Of course, the token itself is not reusable by the incremental parser.  i.e. if the parser chooses
is asking for *tokens* (as opposed to nodes), then we can't return 'public' as an identifier.  This
is not the same as what the scanner would have produced, and that could screw up the parser.

This speeds up incremental parsing great in files that contains lots of keywords-as-identifiers.
Libraries tend to hit this a fair bit as there is quite a lot of use of names like 'string' for
parameter names.

Conflicts:
	src/compiler/syntax/scanner.ts
Update LKG.
Reduce size of our syntax node definitions. (Hopefully to drop JIT time).

Conflicts:
	src/compiler/syntax/syntaxNodes.generated.ts
Update LKG.
Slim down Make node construction faster by removing conditional checks.
Remove tokenKind.  We're going to pack information in the token, and will need to recover the kind from that.

Conflicts:
	src/compiler/document.ts