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;
```