Support static/self::TypeConst access

Summary: One thing that will make Type Const a compelling feature is the ability to access them via "self" and "static" access. For the most part the semantics of "self" and "static" in a type access hint is the same as self and static in expressions accessing constants.

For "self" we are able to resolve during naming, so we replace all references before reaching the typing phase.

For "static" it is a bit more nuanced. When expanding a type access we have to keep track of what the current class we are examining. For example

```
class A {
  type TC = int;
  type TC_static = static::TC;
}

class B {
  type Foo = A;
  type Bar = static::Foo;
}
```

Then when trying to resolve B::Bar::TC_static we do the following:

```
type = B::Bar::TC_static, root = B, tconst = Bar, rest = TC_static, static = ""
type = (static::Foo)::TC_static, root = static, tconst = Foo, rest = [], static = "B"
type = (B::Foo)::TC_static, root = B, tconst = Foo, rest = [], static = "B"
type = A::TC_static, root = A, tconst = TC_static, static = "B"
type = static::TC, root = static, tconst = TC, static = "A"
type = A::TC, root = A, tconst = TC, static = "A"
type = int
```

From the above example it should be clear that "static" refers to the previous root (after resolving "static"). The other thing to note is we have to expand through type defs. This is due to the fact we use type defs as part of the representation of these.

Reviewed By: @jwatzman

Differential Revision: D1732621