Add Callback mechanism

To make writing callback easier, the Callback templates are introduced and makeCallable() is handy to bind functions to objects. Here is an example.
https://github.com/visualzhou/simple-rpc/blob/callback/test/callback_test.cc#L85
```
  rpc::Runnable* cb = makeCallable(&Counter::inc, &c); // Bind function to object.
  pool->run_async(cb); // cb is deleted after running by pool.
```
More examples could be found in that test file.

The best thing is currying. It is demonstrated in 
https://github.com/visualzhou/simple-rpc/blob/callback/test/demo_client.cc
Here is the function declared.
```
class CallbackHanler {
public:
    void onCallback(Client* cl, int* rpc_counter, Future* fu) { ... }
}
```
Call `makeCallable()` to get a FutureCallback.
```
    CallbackHanler handler; // Thread-safe
    for (int i = 0; i < concurrency; i++) {
        FutureAttr attr;
        attr.callback = makeCallable(&CallbackHanler::onCallback, &handler, cl, &rpc_counter);
        // Start the endless chains of callbacks until close_and_release.
        Future* fu = MathProxy(cl).async_is_prime(rand(), attr);
        if (fu != NULL) {
            fu->release();
        }
    }
```

Now the Runnable and FutureCallback are just `typedef` and their interfaces are kept the same as before. All the code we have now still work.
```
typedef Callback<void> Runnable;
typedef Callback<void, Future*> FutureCallback;
```

Notice we need to wrap all logic in classes and have its object before using it. This is reasonable because all logic is organized together instead of spreading all around. Image the change when writing coordinators in Lynx and throughout tests.