Improve Reflect hasField/field for js target, improve Math for js
target.

All unit tests bar 1 pass.

Failure requires change in genjs, compiles 1["foo"] as 1.foo
need to check that object (in printed js) is not a number before
using field access.
Ensure that TField with lhs as an int/float is generated like
(number).field instead of the invalid JS number.field
Added back in necessary code to permit Reflection on Math, moving
back to using only std/Math instead of js specific file.
Rever changes to Reflect.field
really revert... sigh
Ensure semicolon is inserted after class defn with no constructor

Main = function () { };

instead of

Main = function () { }

(This is a JSHint error).
Don't avoid a semicolon after static field gen.

class Main {
    static function main() {}
}

generated

Main.main = function () {
}

instead of

Main.main = function () {
};

(Another JSHint error)
Prototype/$extends jshint fixes.

Ensure a class prototype, when not using $extends has a semicolon
inserted after the prototype.

Class.prototype = {
     ...
}; <-- without, a jshint error.

Change inherit to Inherit and remove a semicolon after declaration.
Fixes 2 jshint errors about an unecessary semicolon, and constructor
names not starting with capital letter.
Only generate Math.__name__ if necessary, add ; after package defn.

before:

var js = {}

now:

var js = {};

etc.

Also moved from Math.__name__ being defined for js in Math __init__
to a special case (due to being extern) in genjs to generate __name__
the same way other classes have it generated on demand.
Move , in field seperator to previous line. fixes a jshint warning.

{
    x : ..
    ,y : ..
    ,z : ..
}

to

{
    x : ..,
    y : ..,
    z : ..
}
Removed 'is' and 'use' from keywords list.

I cannot find a single source that specifies these as keywords.
Merge branch 'development' into dev_js_improvements

Conflicts:
	genjs.ml
JS optimisations for Std.is.

Generate exact code for typed cases of Std.is(x, T) when T is
known at compile time to be String/Int/Bool/Dynamic/Float.

This is handled as an optimization step specifically for JS
which transforms calls to js.Boot.__instanceof appropriately
before DCE kicks in, ensuring that if the only isntances of Std.is
is to one of these known types, then js.Boot remains excluded from
the build nicely.
Added fast-path for Std.is(_, Array).

Uses Object.prototype.toString.call(o) == "[object Array]"

instanceof Array is not full-proof, nor is constructor check when
scripts are run between browser frames.
Semicolon usage.

Removed semicolon after $iterator and $bind definitions (not needed)

Added semicolons after enum definitions, and enum function constructors
Improve optimisation for Std.is when negated

Generate !=, !==, false isntead of ==, ===, true when Std.is
is used in conjunction with !
Set ctx.separator to false after untyped __js__ block.

Effect is to ensure there's no ';' inserted when last character
of __js__ block was { } or :
Remove redundant space at end of __js__ block in string_rec

Caused a ; to be inserted after start of for loop block unnecessarigly.
Added @:shallowExpose

@:shallowExpose works very similarly to @:expose, the difference
that instead of being exposed on the window object (or the exports
object if window does not exist). The class/static field is instead
exposed to the 'surrounding' scope of the haxe generated closure.

This 'sounds' the same as exposing on window, except for the use-case
of having the haxe generated code itself combined with other existing
JS/TS/Coffeescript whatever generate code into another closure where
the Haxe classes/methods really should only be exposed 'to that closure'
rather than the window. @:shallowExpose permits that.

Example:

```js
@:shallowExpose class A {}
@:shallowExpose class B {}
@:shallowExpose("x.y.D") class D {}
@:shallowExpose("x.C") class C {}

class E {
    @:shallowExpose static function e() {}
}
```

Generates:
```js
var $__hx_shallows = {E:{},x:{y:{}}};
(function () { "use strict";
var A = $__hx_shallows.A = function() { };
var B = $__hx_shallows.B = function() { };
var D = $__hx_shallows.x.y.D = function() { };
var C = $__hx_shallows.x.C = function() { };
var E = function() { };
E.e = $__hx_shallows.E.e = function() {
};
Math.NaN = Number.NaN;
Math.NEGATIVE_INFINITY = Number.NEGATIVE_INFINITY;
Math.POSITIVE_INFINITY = Number.POSITIVE_INFINITY;
var $Number = Number;
var $isFinite = isFinite;
var $isNaN = isNaN;
Math.isFinite = function(i) {
	return isFinite(i);
};
Math.isNaN = function(i) {
	return isNaN(i);
};
var $hasOwnProperty = Object.prototype.hasOwnProperty;
var $ObjectPrototypeToString = Object.prototype.toString;
})();
var E = {};
var x = {y:{}};
var A = $__hx_shallows.A;
var B = $__hx_shallows.B;
x.y.D = $__hx_shallows.x.y.D;
x.C = $__hx_shallows.x.C;
E.e = $__hx_shallows.E.e;
```
Optimise Std.int to always generate (v | 0) in compiler.