maintaining (ugly and error-prone) hash tables.

That change revealed an untriggered bug in EvalClock.check_args: it was wrong
to add in subst the substitutions made of the parameters and the arguments (it
is enough to unify the clocks of the pars and of the args). For instance, consider
the node (in should_work/clock/clock.lus)

   node clock5(x :  bool; y:  bool when x; z: bool when y)

and the call

  z2 = clock5(a, b when a, c when e);

I was adding y/b in the subst, which was wrong.

Other minor changes:
 - move const_to_val_eff from Eff to UnifyClock.
 - GetEff.translate_val_exp now returns a substitution, in order to be able
   to unify clock vars and propagate the resulting substitution.

not expanded.

info is attached to all  val_exp. Moreover, this allow to perfrom all
the  type checking  in  EvalType.f, instead  of  doin part  of it  in
GetEff.translate_val_exp.

maintaining (ugly and error-prone) hash tables.

constants that  are not  on the base  clock, add the  suitable "when"
statement if it was not present  in the source code (the lic (and the
ec/lv4) backend  does not  perform such kind  of clock  inference for
constants.

2 source transformations), we add an entry in the EvalType and the EvalClock
tables. Otherwise, when we use EvalType.lookup or EvalClock.lookup, an error
migth be raised.

When a node P::n1 wants to access to a node P::n2, it is ok to
search for it in the boby of P.

conjunction of some program transformation (-ei or -esa).

In Lazycompiler.node_check_do, I've forgotten  to put the node i/o in
the local_env table in the case of node alias.

nodes (e.g., map<<+,2>>). While fixing  that, I put all the functions
that deals with polymorphism into a new (Eponymous) dedicated module.

The idea to be able to expand polymorphic node is basically the same,
as the one for printing polymorphic  nodes: we need to wait until the
type is instanciated (in GetEff).  That delay is implemented by using
a stack of nodes.

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.

(--inline-iterators) to activate it.

nb : do not inline completely nested iterator calls (yet, cf TODO).