Differentiate between "global code" and "eval code" scripts.

Add a separate js_loadeval for "eval code" scripts, and let
js_do/loadstring create "global code" scripts.

js_newscript called with the NULL scope is equivalent to 'eval code'.
js_newscript called with the J->GE scape is equivalent to 'global code'.
js_newfunction is created with the lexical scope, i.e. 'function code'.
Fix JSON parsing problems:

 * false/true/null keywords
 * empty arrays and dictionaries
 * single quoted strings (are not allowed)
Add static to some functions that should have it.
JSON.stringify: support 'space' argument.
Add missing js_endtry call in Fp_toString.
Fix bug in maintaining property enumeration list.

The tail pointer in the linked list head was mismanaged, leading
to using free memory when properties are inserted after deleting
a property such that the tail points to the deleted node.
Fix bug in js_setlength when used for relative indices.
Fix bug in Array.prototype.splice().
Oops. Remove stray printf.
Track array sparseness to be smarter in jsV_resizearray.
Optimize js_stringtofloat to use integer conversion when possible.

Use strtol conversion when the number is 9 digits or less,
has no decimal point and no exponent.
Fix bug in Math.random().

Return value should be 0 <= x < 1. Fix typo and divide by RAND_MAX + 1.0
to avoid integer overflow.
Use of try/catch must disqualify a function from being lightweight.
Remove duplicate js_newerror prototype.
Fix ifdef order to allow building jsdate on cygwin.
Garbage collect (some) strings.

Separate literal/interned and garbage collected string types in js_Value.

js_pushintern/js_tointern are convenience functions to push/pop strings and
automatically intern them (so that the string pointers are guaranteed to be
stable).

js_pushliteral should push stable strings (either interned or actual literals).

js_pushstring will copy the string into garbage collected memory.

The pointer returned by js_tostring is guaranteed to be stable only for as long as
the stack slot it came from remains untouched.

Some uses will always cause a string to be interned:

 * Using it as a property name.
 * Wrapping it in a new String() object.
 * Strings returned by toString().
	ToPrimitive must not clobber the stack, so the result has to be unrooted.
 * Numbers converted to strings (by js_tostring)
	Likewise, we have nowhere to store the temporary string here.
	Passing in a scratch buffer to js_tostring could help this problem.
	Mostly an issue with array accesses (OP_GETPROP, etc) so an auxiliary
	function and we don't have to clutter the API needlessly.
Add js_itoa for faster conversion of unsigned int to string.
Make js_toprimitive (and by consequence js_tonumber/string/...) in-place.

Any coercion between types may overwrite the stack slot with the coerced
value. This is usually not a problem, but if you need to preserve the
original value, you should copy it to another stack slot before running
any functions that may coerce the type (anything involving ToPrimitive).

This change lets us avoid interning the result of toString().

If we later add short strings (embedded in js_Value and js_Property
structs) then we can also avoid creating a garbage collected string or
interning the result of js_tostring on a number.
Add short strings (with data embedded in js_Value).

Allows js_tostring to avoid either interning strings converted from
numbers or creating lots of garbage collected strings.
Add user context pointer and flag argument to js_State constructor.