Fixes to type guards

Two minor fixes to type guards.

First, a fix to #1070. A type guard now has an effect only if the narrowed type is a subtype of the variable type.
```typescript
var x: string | number;
if (typeof x === "boolean") {
    var b = x;  // x still of type string | number
}
```
We could consider reporting an error, but I'm not sure about that.

Second, type guards now consistently affect code in nested function expressions. For example:
```typescript
function foo(x; string | number) {
    if (typeof x === "string") {
        var f = function() {
            return x;  // x of type string here
        }
    }
}
```
Before this change, only code in expression bodied arrow functions was affected by type guards (which was an inconsistency and a bug). In the example above, it is possible that `x` isn't of type string by the time `f` is called (because of an assignment to `x` outside the type guarded code) but it is already a fact that we don't track assignments that happen in functions called from the guarded code, and it really is inconvenient if type guards don't affect nested function expressions.
Given the rules have changed can you add this test case here 
```TypeScript
var val1: number | string | boolean;
if (typeof val1 === "string") {
    var val2 = val1; // string;
    function foo() {
        var val3 = val1; // Function declaration new scope = number | string | boolean
    }
}
```