Updates to prevent fourslash tests from failing.

Tests completionListInTypeParameterOfTypeAlias1 and 2 were failing before
this commit. The completions.ts changes are self-explanatory but the
parser.ts change is that I added semicolon as a terminator for type
parameter lists. The reason is the code in the failing test looks like:

```ts
type List1<
type List2<T> = T[];
type List4<T> = T[];
type List3<T1> = ;
```

When type parameters were not allowed to have their own type parameters
that code parsed as type `List1` with type parameters `type` and
`List2`, with a missing comma between `type` and `List2`, and then the
unexpected `<` from `List2<T>` was parsed as the list terminator for the
assumed `List1` type parameter list.

However now that type parameters are allowed to declare their own type
parameter lists, the `<` from `List2<T>` is no longer unexpected so
`List2<T> = T[]` is parsed as a syntactically correct definition of a
type parameter `List2` that has its own type parameter `T` and a default
of `T[]`. Then it ignored the unexpected semicolon and parsed the third
line in exactly the same way as the second line, as additional type
parameters of `List1`, with `List4<T>` defining its own child type
parameter `T`.

So adding semicolon as a type parameter list terminator stops the
assumed `List1` type parameter list at the end of line 2.

Author: kpdonn

src/compiler/parser.ts

@@ -1609,7 +1609,8 @@ namespace ts {
                     return isVariableDeclaratorListTerminator();
                 case ParsingContext.TypeParameters:
                     // Tokens other than '>' are here for better error recovery
-                    return token() === SyntaxKind.GreaterThanToken || token() === SyntaxKind.OpenParenToken || token() === SyntaxKind.OpenBraceToken || token() === SyntaxKind.ExtendsKeyword || token() === SyntaxKind.ImplementsKeyword;
+                    return token() === SyntaxKind.GreaterThanToken || token() === SyntaxKind.OpenParenToken || token() === SyntaxKind.OpenBraceToken ||
+                        token() === SyntaxKind.ExtendsKeyword || token() === SyntaxKind.ImplementsKeyword || token() === SyntaxKind.SemicolonToken;
                 case ParsingContext.ArgumentExpressions:
                     // Tokens other than ')' are here for better error recovery
                     return token() === SyntaxKind.CloseParenToken || token() === SyntaxKind.SemicolonToken;

src/services/completions.ts

@@ -1776,6 +1776,7 @@ namespace ts.Completions {
                         containingNodeKind === SyntaxKind.InterfaceDeclaration ||                   // interface A<T, |
                         containingNodeKind === SyntaxKind.ArrayBindingPattern ||                    // var [x, y|
                         containingNodeKind === SyntaxKind.TypeAliasDeclaration ||                   // type Map, K, |
+                        containingNodeKind === SyntaxKind.TypeParameter ||                          // <T<_T, |
                         // class A<T, |
                         // var C = class D<T, |
                         (isClassLike(parent) &&
@@ -1803,6 +1804,7 @@ namespace ts.Completions {
                         containingNodeKind === SyntaxKind.ClassExpression ||                        // var C = class D< |
                         containingNodeKind === SyntaxKind.InterfaceDeclaration ||                   // interface A< |
                         containingNodeKind === SyntaxKind.TypeAliasDeclaration ||                   // type List< |
+                        containingNodeKind === SyntaxKind.TypeParameter ||                          // <T< |
                         isFunctionLikeKind(containingNodeKind);
 
                 case SyntaxKind.StaticKeyword: