E.g., when creating a fresh var using the name of "L1", I was creating a var names "_L11", and then
"_L12", and so on. But if a var is named "L11", "_L111" is created. If if "L1" is used to generate
11 frash vart names, the name "_L111" clashes !!!

The fix contist in adding an underscore before : "L1" produces "_L1_1", "_L1_2", ..., and "_L1_11".

nb : the naming scheme is still wrong for other reasons... Next fix.

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.

expanser to expand the mentioned node.

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.

instanciated by a polymorphic operator.

as extern constants.

Also  fix  a  bug   in  the  struct/array  expanser:  when  expanding
structured constants  into val_exp,  I need to  add a entry  into the
type and clock val_exp tables.

 - expr such as "current x,y" should be written "current (x,y)"
 - abstract   struct  or   array   types  were   handled  as   extern
   types, which  prevent the struct  and array expanser to  work them
   out. In order to fix that, I have added an Abstract_type_eff variant
   to Eff.type_ which contains the concerte type.

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.

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.

+ more work on the release dir.

To  do  that, we  centralized  the ident  name  creation  into a  new
dedicated module Name.

+ fix should_work/NONREG/param_node.lus, we contained a combinational loop.

(--inline-iterators) to activate it.

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

by position). Rename ExpandPack into InstanciateModel.

change the parser and accept only clock expressions after a when.

A clock is now made of 2 idents: one for the clock constructor, and
one for the clock variable.

simple, and also avoids  3 shift/reduce conflicts. It also make
the pragma stuff more homogeneous  and simple to explain in the
manual.

Moreover, pramgma  are no  more attached to  AST nodes,  but to
lexemes.

internal errors.

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>>;

+ enhance  error msg  (which helped finding  the bug, but  that migth
also be useful for ed-users...).

enum nor a bool.

to avoid name clashes in the lic.

account into the expected output of the non-reg tests.

test/should_work/Pascal/t1.lus

+ typos