In  short, the  rationale for  this change,  is that  it is  having a
recursive node_exp is
- useless,
- too complicated,
- wrong w.r.t. nesting iterator calls

In long:

- It is useless because, at the  Eff level, a node cannot call itself
  via one  of its  static arg (which  was where the  recursivity came
  from).

- and indeed, it  is much simpler to consider that  a static arg node
  can only be ident.long that identifies a node alias.

  This  means of  course, that  nested iterators  have  been unnested
  before,   inventing  alias   node  names   along  the   way...  And
  polymorphism makes thing difficult once again.

- But the  *big* problem  with a recursive  node_exp is that  it make
  things very  complicated to (lic)dump nested  iterator call because
  of polymorphism!   Actually, it  even makes thing  complicated when
  the iterators were themselves not nested in the source code !

  Some ugly  things were done in  LicDump to unnest  those calls when
  printing node_exp.   But this uglyness  have a price:  tricky code,
  and bugs! Indeed, nested iterators calls were wong for example when
  using  the --inline-iterator  mode (but  i would  not  be surprised
  that is wrong in other cases...).

Hence,  LicDump  is  simpler,  but  of course  LazyCompiler  is  more
complicated.  But  this  is  reasonable:  a  pretty-printer  is  not
supposed to be complicated.

polymorphic operators.

For instance, when LicDumping expression such as

    map<<map<<+,4>>,5>>

an  alias  node was  created  for  "map<<+,4>>"  (to unnest  iterator
calls). Fut this node is intrically overloaded (polymorphic). In this
change, we  look at  the type this  innr call  is used to  generate a
specialised (mono-morphic) version of the node alias.

Note that we currently still generate type variable when users write

     node mymap = map<<+,4>>;

The  idea  is  the  following:  each  time  a  nested  iterator  call
(map<<map<<n,3>>,4>>) is  encountered, we  create a fresh  alias name
(create_alias_name) ad we  add it in the node_alias_tbl.   At the end
of the  compilation, LicDump.dump_node_alias is  called, which prints
the definition of those node aliases.

For example, the expression  "map<<map<<n,3>>,4>>" is printed like this:

    map<<_node_alias1, 4>>

and later, the node alias is defined:

    node _node_alias1(x:int) returns(y:int); let y = map<<n,3>>(x); tel;

It  does not  work, I  have changed  my mind  to use  a  more general
clocking algorithm based on  unification. I commit that current state
just in case I change my mind again...

type_eff_ext into type_eff btw). The  rationale is to be able to type
alias           on           polymorphic          nodes           (cf
test/should_fail/semantics/bad_call03.lus,  that now  have  a correct
error msg).  It also makes  to code more compact (no more translation
from one  to the  other), and more  general (type_eff_ext  being more
general than type_eff).  User polymorphic nodes should be easy now.

move all the code in parsey.mly into parserUtil.ml (ease the debug).

and PredefEvalClock.