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.

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).

SolveIdent.recognize_predef_op  that  replaces  node call  by  Predef
constructor  when   necessary,  via  a  complete   traversal  of  the
SyntaxTree (instead  of doing it  in the parser). The  rationales for
this change are that:

- it is quite tedious to do it in parser as multiple locations are involved
- I did missed some locations
- It makes the parser more focused on parsing issues
- that traversal  is a first step  do deal with  idref solving (hence
 the name of the new module that contains that function

Note that lsrc/test/should_work/fab_test/lecteur.lus was using
"plus" as a variable ident, which raised an error, which

(support for fill, red, etc. is coming soon).

In order to add support  for iterators, I have extended the by_pos_op
(and the by_pos_op_eff) data type with a list of static arguments. In
other words, iterators are handled as a particular case of predefined
operators.

operators. Predef contains the abstract syntax of those operators (taken
for SyntaxTreeCore.by_pos_op), and PredefSemantics contains:

 - const_eval: that says how to statically evaluate constants
 - type_eval: that provides the type profile of predef operators
 - clock_eval: that provides the clock profile of predef operators

The code in EvalConst that dealt with predef const evaluation is now in
Predef.const_eval

change is
	- make the parser simpler
	- make the compilation simpler
	- make everything simpler actually...
	- accepts more correct programs.
	- etc.

Indeed, before, we had specific syntax nodes for
	- extern nodes
	- aliased nodes
	- abstract nodes
	- normal nodes
which leads to duplicate code everywhere. Now, we have a more generic
representation.

The nice thing is that the parser is much simpler, and a lot of
duplicated code is avoided (for example, extern and abstract nodes do
now share the same code).

The bad thing is that we have more "assert false" lying everywere due
to this «too rich» representation, in order to deal with cases
that can never happen. For exemple, we have to do something with
nodes that have  both an alias and a body. This cannot happen of
course, so we issue an "assert false", which is a little bit painful,
as it have been rejected by the parser anyway.

Moreover, for some reason, external node params could not be clocked,
and cannot have static params. Maybe it is not possible to compile
such nodes (I don't know yet), but we should not raise a syntax error IMHO.

Somehow, what was done was very similar to ask the parser to perform type
checking.

ParserUtils.flat_flaged_list -> ParserUtils.flat_flagged_list

Ident.t is now an abstract data type (instead of a string).
fullid is turned into an Ident.long, and is also made abstract.