This (large) patch also makes related changes to a number of identifiers.

We now build normal syntax nodes during parsing, re-using node types from
the expression syntax (E_VAR, E_BINOP, E_PRE, E_SUBSCR, E_FUNC). Together
with the recent change in generating types, this means we no longer need the
backward parent links in the type structure. Most of the code in var_types.c
is now much easier to understand and modify.

Also made the tentative change to represent "const" not as a type node with
a child pointer, but rather with a boolean flag. This is in anticipation of
adding the "pv" type operator in the hope that using yet another flag to
represent it will make analysis of a type easier. It could well be that I
revert this change if it turns out that this makes things more difficult. A
first indication is that in var_types.c this already complicates some of the
routines. So I left most of the T_CONST cases in there, only disabled them
with #if 0...#endif.

We currently use it only to find out whether a given expression has
function type (or pointer to function), because in that case we must
supply arguments for the implicit parameters.

Previously literal C code blocks from the initial definition section
(before state sets) went before everything else, and those from the
final definitions section (after the state sets) were grouped together
at the end. Now we try to generate stuff in a way that keeps the
relative order the same as in the SNL source.

This approach has limitations: top-level variable declarations must be
generated in one block since in re-entrant mode they all go into a large
struct; there are also auto-generated delarations for SNL function
definitions. Both are now placed (in this order) after all the other
definitions in the initial definition section.

The resulting limitation for literal C code (it cannot refer to global
SNL variables) is the same as it was before. A similar limitation now
applies to SNL functions defined in the initial section (which makes
them less useful when defined there).

The new SNL functions make a lot of embedded C code, especially C
function definitions, obsolete. This means the header file is not as
useful as I thought. On the other hand, function definitions may depend
on stuff that has been declared before. So it becomes more important to
keep the order of definitions in the output as similar as possible to
that in the input file (the variables struct being the most notable
exception). Grouping some stuff in a header file and other stuff in the
C file makes this almost impossible.

This change is no more than a one line addition to the lexer spec!

There are three reasons for this move:
- the change in terminology never cought on
- it causes unnecessary naming conflicts, especially now since many more
  things that previously were in escaed C code can now be coded in SNL
- the next version will introduce new and better syntax for this anyway

This came out of the desire to allow function definitions intermixed
with c code and other definitions, and not only at the end of the
program but also in the initial definition section. Some amount of
re-factoring was necessary in the analysis part to make this possible,
since previously we had only one definition list per scope and now the
program has two. More changes were needed in the code generation, mostly
to pick apart the stuff that the parser now mixes together, and also to
beautify the generated code. The separate declarations for function
definitions are no longer in the header file; they are static anyway.

One difference in behaviour is that now the extra escaped C code
sections at the end of a program are paced *before* the state set code.
The advantage is that extra prototypes are no longer needed (except if
the functions call each other resursively). This change should not break
existing programs, since C functions cannot call state set functions. 

Since we now resolve built-in functions as well as constants during
analysis, we no longer need to access the symbol table in the code
generator. This means we can get rid of an ugly hack. The gen_ss_init
procedure is also no longer needed and has been removed.

We give the hint to use option +p only if the function actually supports
multi-PV arrays. We know this by examining the add_length column in the
builtin function table (functions that support them must add the array
length as implicit argument to the call).