Prior to this change we always canonicalized method's type parameter
names to their receiver counterparts. This was mainly necessary to avoid
errors when we needed to reference method's type parameters inside a
type generic factory function, e.g. when initializing method's
reflection metadata.

Such implementation, however, was causing a bug when minification is
enabled:

 1. Methods are compiled first, variable names are allocated to their
    type parameters and the association is stored in the package
    context.
 2. The allocated variable name is marked as in use within the mathod's
    functionContext, up to the enclosing generic factory function
    context, but not at the package level.
 3. Type definitions are compiled second. Because the type's typeparams
    are already associated with variable names, these variable names are
    used. The process of allocating a new variable is omitted and the
    previously allocated name is not marked as allocated within the
    type's generic factory function.
 4. A new variable inside the type's generic factory function is
    allocated, and its name may collide with the type param's variable
    leading to errors.

With this change, canonicalization is only done if we are outside of
the method's functionContext. That way no variable name is associated
with type's typeparam objects while compiling the method, and the JS
variable is correctly allocated and marked as in use.