by using a SK_OverloadedConstructor instead of a SK_Constructor

(while matching types of instances)

this adds local functions of instances and generic cases to the ifi_local_function_indices,
in order to check the kinds of these local functions

by using the reversed groups (constructed in reverse order)

if a constraint of a class without members is reduced, and all classes in the constraint of that class appear
in the reduced constraints for a variable, add a constraint for the original class for that variable
(this causes removal of the other constraints later), to prevent functions with too many constraints

(the type definition has a * on the left),
add Bool to GTT_Constructor to indicate uniqueness,
generate TCE_UnqType in TypeCode for unique GTT_Constructor's,
this uniqueness property should be propagated, but this is not implemented yet

to the list of all type attributes
(not adding these type attributes caused a type error),
this also happens for function types that are specified by the programmer,
the universally quantified type variables are however not added to the list of all type variables

for example: [0 \\ [] <- [[]]]

makeConsExpressionForGenerator, makeNilExpression and makeConsExpression

(undo: check the type of instances defined using :== (maybe the parser should reject these instances))

this is necessary because in module type_io these pointers point to TVI_Normalized values that
could be overwritten by this function

argument fun_type of function determineProducers was changed by a record pattern match,
rename the argument to consumer_type

prevent crash when writing .tcl file with extensible algebraic types (not yet implement in the dynamic linker)

to prevent crash in collectVariables

to avoid abort in collectVariables for a BoundVar

allow integers and strings as consumer for generic functions (to optimize use of generic info).
use PR_CurriedFunction instead of PR_Curried for local macro functions that are good producers.
check the arity of the function to be generated already in determineProducer,
if too large, don't yield a producer which will be rejected later,
to allow optimization of producers in subsequent arguments.
optimize trivial function calls (with arguments) before optimizing arguments,
treat constant function as trivial function.
if a function call has two identical arguments,
generate a specialized function that shares these parameters.
specialize functions with zero arity constructor arguments,
if the function is a generic function, or the constructor is a generic constructor.

add generic case definitions in definition modules for the types used to make the generic representation,
in generic case definitions in definition modules specify what generic info and dependencies are used

add type constraints in constructors and function arguments with universal quantifier (from iTask branch)

fix name of type function