makefile: Add warning-tests command too
parser: Make WITH + compound stack work like most other compound blocks

Previously, parser.stmt.with held the current WITH context, while the nodes
on stack represented the previous ones.

Now it works like most other compound blocks, i.e. parser.stmt.with is just
a pointer into the stack.

This gives us access to other fields of the stack nodes, such as
FB_CMPSTMTSTK.scopenode, which is not part of FB_CMPSTMT_WITH. In other
words, now it becomes possible to give WITH a temporary scope using the
same code as for many other compounds.
WITH compounds: Add implicit scope and extend lifetime of temps

This fixes bug #522 (WITH destroys temporary UDT vars before entering
block), by adding an implicit scope to WITH blocks, which captures any
temporaries from the WITH expression, allowing us to easily turn them from
temp vars into normal implicit vars and drop them from the AST dtor list.

The scope then causes the vars to be destroyed at scope breaks or scope
end. This way we extend their lifetime.

By doing this for all temporaries in the WITH expression, and not just the
specific temp var which the WITH is intended to access, the problem is
simplified. Determining the specific temp var which is accessed by the
WITH can be difficult, because the WITH expression may be complicated.
Often it's just a simple VAR, but it can also be a DEREF, for example:
	with *(@type<UDT>() + 0)
I.e. it's non-trivial to determine which temp var is the special one.

Another reason for extending the lifetime of all temps as a group is that
they may reference each-other. I can think of at least a situation like
this:
	with f(type<UDT>())
where the function f() returns a new temporary that references the temp
it's been given in some way. So if we extend the lifetime of the function
result, then we must also extend the lifetime of the other temp which it
references. Considering that astDtorListFlush() explicitly destroys temp
vars in reverse order compared to the order in which they were added,
not "randomly", it seems to me like temps referencing each other is a
supported possibility.

"Negative" effect:
* Adding an implicit scope to WITH blocks means potentially breaking
  existing code: Variables declared inside won't be visible outside
  anymore. Also, GOTOs into WITH blocks will now show "branch crossing
  local variable definition" warnings/errors.

Positive effects:
* #522 is fixed
* more consistency with other compound blocks
WITH compounds: Accept type<UDT>() and UDT() expressions (TYPEINI/CALLCTOR)