This will avoid some translation bug where nested nilables such as T.nilable(T.nilable(X)) get incorrectly translated as X??.

This PR introduce two important concept:

1. Type normalization: transforms a type into a canonical version that is easy to analyze.

    # Returns a normalized version of the type.
    #
    # Normalized types are meant to be easier to process, not to read.
    # For example, `T.any(TrueClass, FalseClass)` instead of `T::Boolean` or
    # `T.any(String, NilClass)` instead of `T.nilable(String)`.
    #
    # This is the inverse of `#simplify`.
    #
    # @abstract
    #: -> Type
    def normalize; end

2. Type simplification: transforms a type in an easy to read version.

    # Returns a simplified version of the type.
    #
    # Simplified types are meant to be easier to read, not to process.
    # For example, `T::Boolean` instead of `T.any(TrueClass, FalseClass)` or
    # `T.nilable(String)` instead of `T.any(String, NilClass)`.
    #
    # This is the inverse of `#normalize`.
    #
    # @abstract
    #: -> Type
    def simplify; end

We need type normalization to implement type simplification. Consider this example:

T.any(T.any(A, TrueClass, T.any(B, FalseClass, T.any(C, NilClass)))

The normalized version of this type is

T.any(A, TrueClass, B, FalseClass, C, NilClass)

Which can then be simplified into

T.nilable(A, B, C, T::Boolean)