Debugger: Add type results to ExpressionInfo.

- In addition to a primitive or value node, expressions can potentially
  result in types as well. As such, extend ExpressionInfo to be able to
  return one, and indicate such a result kind appropriately.
Debugger: DwarfImageDebugInfo cleanups.

- For simply looking up a type, we need neither the register map, nor
  the target interface, as those are only necessary for resolution of
  values and/or locations.
- Fix memory leak. A reference to the target interface was acquired in
  the type context's ctor, but not correspondingly released in the dtor.
Debugger: Minor fix to CLanguageTokenizer.

- Properly differentiate the size of a parsed hex constant in order
  to return a correspondingly sized primitive, rather than always
  returning as 64-bit.
Debugger: Add basic support for types in expressions.

SourceLanguage/CLanguageFamily/ExpressionEvaluationJob:
- Add TeamTypeInformation parameter to EvaluateExpression() hook. Adjust
  implementing subclasses and callers accordingly.

CLanguageExpressionEvaluator:
- Add class InternalVariableID for representing intermediate variables
  generated while parsing an expression.
- When parsing an identifier, if we were passed in a type information object,
  then first attempt to resolve the name as a type. If not matched, then fall
  through to attempting to match it to a value node as before.
- When parsing an atom, check if it resulted in a type. If it did, and there
  still remains more of the expression to parse, then parse the result to see
  what value/variable to try to apply the typecast to. If the result is a
  primitive, generate an appropriate internal variable + value node child for
  it, otherwise use the target variable's child. Then, attempt to typecast it
  as requested.
- Simplify _EatToken().
- If the final result of an expression is a type, configure the result object
  accordingly.

As a result of all the above, an expression can now resolve to a type, allowing
the evaluator to take over the duties of parsing the desired type for a typecast
request in the variables view, and in addition, expressions themselves can now
contain typecasts, which opens up quite a few new possibilities.
Debugger: Fix problem in ArrayValueNode.

- The requested child indices weren't being correctly capped to the
  supported lower and upper bound.
Debugger: Simplify expression parser.

- Remove handling of the power token, as it's not actually valid C/C++ syntax,
  and causes problems when parsing more complex pointer types/dereferences.
Debugger: Cleanups.

SourceLanguage and friends:
- Remove ParseTypeExpression from SourceLanguage, as its functionality
  can now properly be subsumed by the general expression parser, and
  simply becomes another result type thereof.

CLanguageFamily/CLanguage/CppLanguage:
- Remove IsModifierValid() hook, as this is all now handled internally
  in the expression parser.

VariablesView:
- Refactor to handle typecast requests via expression evaluation. Since
  this is done asynchronously, rework the logic to handle recognizing
  expression evaluation results that correspond to a requested cast,
  and handle accordingly.
Debugger: Minor syntax highlighter fixes.

- Add missing if/else keywords.
- Add missing comma that was preventing some keywords from being
  recognized properly.
- Add missing handling of condition operator.