Dev js improvements

Improvements to Reflect/Math for JS target.

Effects Reflect.field, Reflect.setField, Reflect.hasField generating optimal code (including a small change to genjs to prevent incorrect code generation picked up on by unit tests (which pass btw)).

Effects Math.NaN/POSITIVE_INFINITY/NEGATIVE_INFINITY/isFinite/isNaN generating optimal code again when not accessing via Reflection.

It's a shame we can't completely get rid of the additions to the Math object that are necessary to allow reflection to work.. ah well.

Example:

```cs
class Main {
    static function main() {
        trace(Math.POSITIVE_INFINITY);
        trace(Math.NEGATIVE_INFINITY);
        trace(Math.NaN);
        trace(Math.isFinite(1));
        trace(Math.isNaN(1));
        trace(Reflect.hasField(Math, "POSITIVE_INFINITY"));
        trace(Reflect.hasField(Math, "NEGATIVE_INFINITY"));
        trace(Reflect.hasField(Math, "NaN"));
        trace(Reflect.hasField(Math, "isFinite"));
        trace(Reflect.hasField(Math, "isNaN"));
        trace(Reflect.field(Math, "POSITIVE_INFINITY"));
        trace(Reflect.field(Math, "NEGATIVE_INFINITY"));
        trace(Reflect.field(Math, "NaN"));
        trace(Reflect.field(Math, "isFinite")(1));
        trace(Reflect.field(Math, "isNaN")(1));
        trace(Reflect.setField(Math, "POSITIVE_INFINITY", 0));
        trace(Reflect.setField(Math, "NEGATIVE_INFINITY", 1));
        trace(Reflect.setField(Math, "NaN", 2));
        trace(Reflect.setField(Math, "isFinite", 3));
        trace(Reflect.setField(Math, "isNaN", 4));
        // Example of change required to genjs picked up by unit tests.
        trace(Reflect.field(1, "foo"));
    }
}
```

geneating now:

```js
(function () { "use strict";
var Main = function() { }
Main.main = function() {
	console.log($Number.POSITIVE_INFINITY);
	console.log($Number.NEGATIVE_INFINITY);
	console.log($Number.NaN);
	console.log($isFinite(1));
	console.log($isNaN(1));
	console.log($hasOwnProperty.call(Math,"POSITIVE_INFINITY"));
	console.log($hasOwnProperty.call(Math,"NEGATIVE_INFINITY"));
	console.log($hasOwnProperty.call(Math,"NaN"));
	console.log($hasOwnProperty.call(Math,"isFinite"));
	console.log($hasOwnProperty.call(Math,"isNaN"));
	console.log(Math.POSITIVE_INFINITY);
	console.log(Math.NEGATIVE_INFINITY);
	console.log(Math.NaN);
	console.log(Math.isFinite(1));
	console.log(Math.isNaN(1));
	console.log(Math.POSITIVE_INFINITY = 0);
	console.log(Math.NEGATIVE_INFINITY = 1);
	console.log(Math.NaN = 2);
	console.log(Math.isFinite = 3);
	console.log(Math.isNaN = 4);
	console.log((1).foo);
}
Math.__name__ = ["Math"];
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;
Main.main();
})();
```