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.

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. 

Foreign declarations have been a bad idea. This became clear after
implementing indirect calls, because as a consequence you get 'used but
not declared' warnings for calls to foreign functions, too. I could
'fix' that with a bit of effort, but that would be misplaced. The C
compiler will warn about undeclared variables and functions anyway, so
why bother? If you really want to know, perhaps for debugging, use -W
option for extra warnings. If you do, you'll now get the more precise
waring 'treating undeclared object xxx as foreign'.

This simply replaces 'ident ( args )' with  'expr ( args )' in the
syntax. A few more changes in the code generator and we're done.

Members are no longer identified with variables in the syntax. Member
selection "operators" ('.' and '->') are no longer treated as binary
operators. Instead, member selection gets a new syntax node type E_SELECT,
and members (only allowed as rhs of a member selection) are not E_VAR, but
E_MEMBER. This all works because members are not first class in C, that is
"x.(name)" is a syntax error.

This is a simple solution for the recurring annoyance of snc issuing
"undefined variable" warnings.

Declaring members in a foreign declaration becomes obsolete.

This appeared when compiling deeply nested statements.
The solution is to use a dynamically growing stack.

As turned out, the 2.0.x branch supported this, so it is added
for compatibility.

Associating a queue with an event flag is unnecessary. An event
flag can be sync'ed with the variable or not; we can regard
the old form for the syncq clause as syntactic sugar for the new
form plus an additional sync clause.

These types are named like the standard C99 types, but are
implemented using epicsTypes.h since the C99 inttypes.h cannot
be assumed to be available on all platforms. We only add
integer types with sizes up to 32, since 64 bit types are not
supported by CA and epicsTypes defines them only if C99 is enabled.

Goes like "when (<cond>) {<actions>} exit and has same effect as
(and is implemented by) calling built-in pvExit.