overload: Prefer passing literal 0 to ints instead of ptrs

hCalcTypesDiff() used to just return a FB_OVLPROC_HALFMATCH score when
passing a literal zero with some integer type to a pointer parameter.
This meant that such matches would have higher scores than any
int-to-int matches (e.g. passing a literal zero of some integer type to
some integer parameter), because those are scored via
FB_OVLPROC_HALFMATCH - symb_dtypeMatchTB..., which will always produce
lower values than FB_OVLPROC_HALFMATCH.

However, I think that integer parameters should be preferred over pointer
parameters when passing in an integer argument (even if it's a literal 0).
Thus hCalcTypesDiff() now returns 1 instead of FB_OVLPROC_HALFMATCH when
passing a literal 0 to a pointer. This case should still be allowed, but
just rated lower than normal integer-to-integer matches. Thus it will only
be the last resort, not the first choice.
overload: Allow passing constant 0 Byte/Short to pointer params

This makes the behaviour of normal and overloaded calls match.
ast-node-conv allows assigning a literal zero integer to a pointer even if
the integer type's size didn't match the pointer size. hCalcTypesDiff() on
the other hand had a check only allowing this if the type size matched.

To fix this, the non-ptr-to-ptr checking code from ast-node-conv.bas is
extracted into a helper function which is now called by hCalcTypesDiff(),
replacing the bogus size check. This should ensure that both overload
resolution and normal cast/conv checks will behave the same (as far as
passing literal zeroes to pointers is concerned).

This also fixes the issue where it was no longer possible to call Bsave
in -lang qb with 0 as the 2nd parameter (which is a pointer), since commit
07d6977397 in FB 0.90 which turned Bsave() into an overloaded function.
ast-node-conv: Fix comment typo
ast-node-conv: Eliminate unnecessary pointer handling code

The SELECT CASE on both code paths won't be reached anymore in case the
dtype they check respectively is a pointer.
Allow casts between pointers and constant 0 with any integer type

These were already allowed:
	        0 => ptr
	       0l => ptr, but on 32bit only (matching the pointer size)
	      0ll => ptr, but on 64bit only (matching the pointer size)
	 cbyte(0) => ptr
	cshort(0) => ptr

Additionally, the following are now allowed too:
	       0l => ptr on 64bit
	      0ll => ptr on 32bit
	any 0 ptr => any integer type (opposite direction)

Updating hCalcTypesDiff() (overload resolution) accordingly is not
necessary, because it re-uses the code from ast-node-conv since db40150e.