When reading an integer of a specific size and comparing it to an integer of a
larger size where any of the upper bits are set we will now emit a warning
because the comparison is always false.

These will always evaluate to false because the "extra" bytes are non-zero:

uint8(0) == 0x1100
uint16(0) == 0x110000
uint32(0) == 0x1100000000

While I'm here, move a test into a better place for it. I added it in the wrong
place in ccbc405.

Fixes VirusTotal#1918.

Turns out that my first implementation of this was flawed. Things like
uint8(uint8(0)) would cause an error.

To make this a bit easier to follow I changed the lexer return tokens for each
of the integer functions, instead of a single _INTEGER_FUNCTION_ token with an
index value to use when emiting the opcode. By doing this I can then set the
width of the expression based upon the new token types and use that when doing
the width check (instead of inferring the width from the index).

Once we have reduced the integer_function we can set it to an integer with an
undefined value and it will be treated like a normal integer for all operations,
except for _EQ_, which has special case logic to check the width and any
compile-time values.