ast: Separate NEW/DELETE build up from astNewMEM()

since NEW/DELETE don't use MEM nodes at all...
Fix new() to require the placement expression to be in parentheses
Fix missing sidefx removal for "new[sidefxexpr] UDT-without-defctor"
Fix bad cloning of the new[] ctorlist loop code

new[] uses a loop to call the default constructor of each element (if the
type has a defctor). The loop of course uses a label, i.e. the built up
tree includes a LABEL (that declares the label at the top of the loop)
and a corresponding BOP/BRANCH node (that does the jump back up).

The problem is that new[] is an expression, and the initialization loop
is included in the tree by using LINK nodes, instead of being astAdd()'ed
immediately like all (really?) other cases where the compiler builds up
loops like that.

This patch essentially fixes astCloneTree() to handle this case properly.
Even though it's rare, there can be cases when the compiler will clone
an expression tree containing a new[] and its loop.

Now, the new[] loop will be wrapped in the new LOOP node, allowing
astCloneTree() to identify this case. It will duplicate the label symbol,
and then update the copy of the original tree accordingly, especially
the LABEL and BOP/BRANCH nodes, ensuring the cloned new[] loop will no
longer use the same label like the original new[] loop.
(This is similar to how iif()'s falselabel is handled)

Thus astCloneTree() on such new[] expressions won't cause duplicate labels
and bad jumps to be emitted anymore.
Use non-flushing LABEL for the new[] ctorlist loop

The new[] loop code will be part of an expression tree, so the LABEL node
cannot be emitted as a flushing label, that would cause the ASM emitter
to flush() all live expressions, try to reuse vregs, etc.

Instead, the non-flushing version must be used, so the whole expression
tree can be emitted safely (without vregs being overwritten).
Fix missing +BOP -> WstrConcat updating in wstring sidefx removal

For example, SELECT CASE wstring-expression uses astRemSideFx() if
the wstring-expression contains some CALL (i.e. has side-effects),
because it wants to generate:

	selectwcharptr = WstrAlloc( len( wstring-expression ) )
	WstrAssign( selectwcharptr, wstring-expression )

but if there are side-effects it must become:

	wcharptr = @wstring-expression
	selectwcharptr = WstrAlloc( len( *wcharptr ) )
	WstrAssign( selectwcharptr, *wcharptr )

The sidefx-removal temp var is a wchar ptr because that's how
astRemSideFx() handles all string types and also UDTs. Using a reference
is more efficient than creating a full copy, and it may actually even be
necessary because later taking the address of the reference will give the
correct result, while taking the address of a full copy would return the
address of the full copy, not the original expression.

In case there are no side-effects, the ARG nodes in the WstrAlloc() and
WstrAssign() CALLs invoke astUpdStrConcat() and all is well

In case there are side-effects, that's no longer the case, because the
argument to the WstrAlloc() and WstrAssign() is just the *wcharptr,
not the original wstring-expression.

On top of that, astOptimize() will not handle the wcharptr assignment:
	wcharptr = @wstring-expression
because it only handles wchar/wstring assignments as in:
        wstring = wstring-expression
so astUpdStrConcat() won't be called from there either.

This patch adds the astUpdStrConcat() call to astRemSideFx(), which is the
code that's taking a string expression and turning it into an assignment,
which however is not a string assignment, but just a pointer assignment,
so it won't be handled by astOptimize().

The lack of +BOP -> WstrConcat updating resulted in bad code being
generated (causing the program to crash at runtime). In theory the
bug could show up with any constructs using astRemSideFx(), but in
practice almost all string expressions will either end up in string
assignments (handled by astOptimize()) or as string arguments (handled
by ARG nodes). SELECT CASE might just be the only case where the bug
could show up...
Remove dead code generated by astRemSideFx()
ast: Add an assert() to astCloneTree() to check for LIT/JMPTB nodes

... which (currently) are not handled properly by astCloneTree(),
so cloning would result in dangling pointers will all kinds of
unpredictable results.