Remove compile-time checks for float div by constant zero

Floating-point division (/) returns INF in case of division by zero,
and the compiler should also handle constant expressions that way.

This partially reverts commit 8528fde4465f27f09da557afb8b3fdcbd57ca54e.
Use "conv overflow" warning instead of "math overflow" error

- This removes the math overflow error shown by constant conversions to
  float when the constant that is being converted does not fit into the
  target data type.

- Instead, a "overflow in constant conversion" warning will be shown
  if there'd be an overflow when converting a constant to SINGLE.

- The check for conversions do DOUBLE is removed. Assuming doubles can
  hold all values that the other types can, the warning would never be
  needed, and just show false positives for INF values and such.

This makes the constant conversion to float checking behave much more like
the constant conversion to integer/longint checks.
astCheckConst(): Remove duplicate/unnecessary warnings

astCheckASSIGN() and astCheckConst() now have a parameter telling them
whether or not to show warnings.

If there's an astNewASSIGN() more-or-less immediately following the
astCheckASSIGN() then we don't want the astCheckASSIGN() to show warnings,
because the astNewASSIGN() will take care of that.

In case of default values for function parameters the astCheckASSIGN()
is the only thing that's done, so the warnings should be shown then.
astNewUOP(): Remove redundant op check
ASM backend: Make CSNG(DOUBLE) truncate to SINGLE if needed

The problem is that for statements like

	double1 = cast( single, double2 )

fbc generated just a load and a store:

	fld qword ptr [ebp-...]
	fstp qword ptr [ebp-...]

and since the FPU stack (st(N) registers) won't truncate double (qword)
to single (dword) automagically, no cast to single would happen here.
It was equal to:

	double1 = double2

It seems necessary though that csng() converts the value to SINGLE,
after all it was explicitly specified. Cases like this:

	single1 = double2

do not have this problem because the load/store code generated for them
is enough to do the conversion:

	fld qword ptr [ebp-...]
	fstp dword ptr [ebp-...]

(note qword vs dword)

The way to get the conversion for csng() is to use a temp var on stack,
into which the SINGLE value is temporarily stored and read back into
the FPU stack (now possibly truncated). After that, any stores from the
FPU stack will use that truncated value and give the correct result.

This patch adds the new emitter operation CONVFD2FS (double to single)
which does the additional store to stack & read back from stack.
With that,

	double1 = cast( single, double2 )

results in the following sequence:

	fld qword ptr [esp+...]

	fstp dword ptr [esp+...]
	fld dword ptr [esp+...]

	fstp qword ptr [esp+...]

(note the additional store to stack & read back from stack)
This matches the code generated by GCC for C code like:

	double1 = (float)double2;

The additional code is generated from astLoadCONV() for conversions from
DOUBLE to SINGLE. However, this patch also adds some checks that prevent
the additional code from being generated in some cases where it's clear
that it's not going to be needed, such as:

	float1 = csng( double1 )

The DOUBLE to SINGLE truncation done by cast() is unnecessary here,
because the value will be truncated when stored into a single anyways.

This patch also includes a fix for the compile-time evaluation of DOUBLE
to SINGLE conversions; instead of doing nothing it will now truncate the
float value stored in "FBVALUE.float as double" using csng(). Note that
this relies on the fixed csng(), requiring the compiler to be rebuilt
with itself after this patch.
Show const overflow warning even if arg/param differ only in signedness

This patch ensures that the warning will be shown in cases like this:

	sub test( byval i as integer )
	end sub

	test( &hFFFFFFFFu )

in order to match the behaviour of this:

	dim i as integer
	i = &hFFFFFFFFu
Fix BYREF cast( args ) (previous commit regression)
rtlAddIntrinsicProcs(): Move sub/function code out of operator code path
Remove "mcount" + some others from global namespace

Under BASIC mangling mcount becomes MCOUNT, so there is no collision
with the real mcount() function, so it may aswell be allowed.

It's true that there's a huge problem with code such as:

	sub rename alias "rename"( )
	end sub

or even

	extern "C"
		sub rename( )
		end sub
	end extern

because it shadows the system's rename() function without notice.

But having some of the affected symbols in the global namespace to
prevent such redefinition is useless, because *any* symbol can be
shadowed that way, for example malloc() or fwrite() or system() etc.

Overriding any symbol that way can cause lots of trouble, if we wanted to
make Extern "C" safer, we'd have to blacklist all CRT/system functions
used by the rtlib, which is too much work, not to mention that many are
re-#defined to implementation-specific names.

Case-preserving name mangling just has to be used with care.

	http://www.freebasic.net/forum/viewtopic.php?f=3&t=20386