Added min- and max- range-indicators to strings.

Also added flags indicating if a string is lowercase or uppercase.

The min/max is only calculated on demand to avoid any slowdowns.

This makes upper_case/lower_case(X), where X is an already lowercased
string very fast ('search' also utilize the ranges when available, so
search(string,"\0") is very fast if there are no null characters in
the string).

It also speeds up the %s format for get_all_args (at least the second
time a certain string is used) since the function checking for null
characters can now use the fields.

Currently most string operations simply reset the string to unchecked,
as an optimization they could copy the ranges/flag as appropriate.

The + operator already does keep track of the flags and ranges.

For wide-strings the min/max value is somewhat less correct, since
it's saved in a single byte. But '0' still works (you get string(0..X)
for strings with 0, and string(1..X) for strings without 0 but with
any other character from the first 255).
Added get_lax_type_of_svalue. Used for constant:s.

int(0..0) -> zero
int(X..Y) -> int
string(X..Y) -> string

This was done to remove some code duplication, and as an added feature
constant x = "foo"; now allows you to assign "f\xfff" when inheriting.
Switched to power-of-two hashtable for types.

Moved some code that checks for the functionality of the
Removed dead code
Check the real range for strings when getting their type.

As an example:

| Pike v7.9 release 5 running Hilfe v3.5 (Incremental Pike Frontend)
| > typeof("foo");
| (1) Result: string(102..111)
Be significantly more strict when checking vary function types.

The type of objects and ranges of strings and integers are now checked.

Still left to do is function arguments/return values for function
arguments.

Also, bignum numbers and other objects emulating integers (Gmp.mpz as
an example) are not currently 100% correctly checked.

An example that works now:

| class Test1 { int b(); }
| class Test2 { int a(); }
|
| class Foo
| {
|     variant string foo( object q ){ return "Genericfoo"; }
|     variant string foo( Test1 x ) { return "Test 1"; }
|     variant string foo( Test2 x ) { return "Test 2"; }
|
|     variant string bar( int(0..0) s ) { return "0"; }
|     variant float bar( int(1..1) s ) { return 1.0; }
|     variant int bar( int(2..2) s ) { return 2; }
| }

However, the last function in the class that match any given arguments
is always used.

There is no concept of 'best' match.

So, if the 'foo( object q )' variant had been last that one would
always have been used.