Only get the apparent type of a contextual type when needed

[DanielRosenwasser]

Fixes #5598.

Background

For quite a while, it was the case that when seeking the contextual type of a value, we would always get its apparent type afterwards. This was usually the behavior desired - otherwise, you'd typically run into problems with things like object literals and index signatures.

During recent work on string literal types, this turned out to be undesirable because the widened type of a string literal type is the global String type. This was effectively useless because we needed to check whether the contextual type was string literal type or a union with a string literal type, so we separated out the concept of grabbing an expression's contextual type (with getContextualType) with grabbing the apparent type of that contextual type (getApparentTypeOfContextualType).

One thing missed in that change was that internally, getContextualType was calling getApparentTypeOfContextualType unnecessarily. This means that if you had a parenthesized string literal, it could never be contextually typed by a string literal type - it would instead get contextually typed by the global string type.

The reason the apparent type was necessary in some places is that when "digging in" to a type, it's necessary to get the apparent type to recognize its available members, the shape of its type constraint, etc.; however, the apparent type is not needed in simple cases where we simply propagate the type back.

[RyanCavanaugh]

👍