allow multiple dependencies on the same generic function but with different generic dependency variables

remove OBJECT,CONS,RECORD,FIELD constructors from generic representation for generic bimap if possible

in function copy_macro_or_local_macro_function, first copy the dynamics in the list, store them using
EI_DynamicCopy, use if available while copying, remove the copies at the end of the function

add function compare_members_of_exported_classes to compare
number of members of class definitions in definition and implementation module earlier,
stop checking after checkIclInstances if an error has occurred,
both to prevent compiler crashes for incorrect programs

convert member types in module backendconvert,
store pointer from field selector to member type in backend with BESetMemberTypeOfField

try to find a TC dictionary that is used in a dynamic expression also in the dictionaries of constructors
with dictionaries that are used in a pattern match.
First try to find them in convertDynamicTypes in dynamic patterns and function constraints, if that fails,
create an EI_TypeOfDynamicAndTCsToFind, and try again in updateExpression, if that also fails report an error.

during fusion, mark unused producer (PR_Unsed) expressions and variables with VI_NotUsed and ExprToBeRemoved

add type GlobalInstanceIndex,
add function collect_imported_instances to module explicitimports,
remove unused Position from si_qualified_explicit

[ReferenceCount] usually consists of many RC_Unused,
these lists are replaced by a single ReferenceCountsAllUnused

print expression in error message in cannot_unify

should be converted in module convertDynamics, instead of storing a list with one nilPtr in fi_dynamics,
remove unnecessary Let expressions with unused variables by
initializing with VI_NotUsed instead of VI_Empty

(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

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)

change GenericInfo

before copying the producer, the type variables are modified
to use the type of the producer when updating the types in cases and lets,
otherwise a polymorphic type may be specialized, possibly causing a type error later

add constructors PE_Matches and IsConstructor in module syntax

adjust imports