Add new way of doing remoting

Basically, each API class is a regular class that implements
"RemotingAPIClass".

And you have a file (Mine is called "app/Api.hx") that implements
RemotingApiContext, and has a field for each API that we want to include.

Basically then we have a build macro do the rest of the heavy
lifting, including:

 * Setting up proxy classes
 * Emptying the function bodies and non-public functions from the
   Api class so it compiles cleanly on the client
 * Instantiates the app.Api fields in the constructor
 * Create the app.ApiClient class with all the same fields, but as
   proxies, and then instantiate those proxies in the constructor.

After all this is done,

 * Each "RemotingAPIClass" should have a proxy.  So "users.UserApi.hx" now
   has "users.UserApiProxy.hx"
 * Each "RemotingAPIClass", when compiled for the client, gives empty function
   bodies, so you don't run into compilation issues where eg js target can't
   access the sys.db.* package.
 * Your "RemotingAPIContext" package before just had a list of fields representing
   the available APIs.  A constructor is now added, and this calls new() on each API.
 * If your RemotingAPIContext was called for example "app.Api", there is now a type
   "app.ApiClient".  This client class takes two arguments to the constructor - the URL
   to use for remoting calls, and an error handler (Dynamic->Void).  When you create the
   ApiClient, it will set up the HttpAsync connection for you, and each of the APIProxies
   will be available as fields for you to access, fully typed:

       import app.Api; // Makes sure the Api is set up and the proxy is build

       var myApiClient = new app.ApiClient("/remoting/", function (e) trace (e));
       myApiClient.userApi.getUser(34, function (u) {
         trace ('Fetched user 34 from the API, their name is: ${u.name}');
       });

 * Your Api class also works on the server, though synchronously:

       import app.Api;

       var myApi = new Api();
       var u = myApi.userApi.getUser(34);
       trace ('Fetched user 34 from the API, their name is ${u.name}');
Added a README for the remoting stuff
Added ClientDs and ClientDSApi (ClientDataStore)

Basically these classes let you request a DB object from the client
using remoting.  At the moment only get() works, which requires a specific
ID to be provided.

Advantages of this approach:

 * Don't need a separate API for simple read operations
 * Each request is cached, so if your client code calls:

       User.clientDs.get(34);

   12 times, it will only make one HTTP request.
 * It uses Promises (from promhx), so that your code will wait patiently
   until the result is available.
 * If you call request User[34], like above, but it has previously been
   loaded already, it will retrieve it from the cache and resolve the
   promise straight away, so there is no delay for your client code and
   no extra load on your server.