[WIP] [TACHYON-152] Client write refactor

Rewriting how client writes out blocks to make it easier to add remote blocks.

The current design is as follows:

Users requests access to a block

```java
Block block = Blocks.createBlock(tachyonFS, blockId, blockCapacityByte);
```

From there, the user can write to it by accessing its `Channel`.

```java
WritableBlockChannel channel = block.write();
channel.write(byteBuffer);
channel.close();
```

When the block is full, write returns -1, so you do this in a loop and create new blocks.

```java
while (buffer.remaining() > 0) {
  int n = mCurrentBlockChannel.write(buffer);
  if (n <= 0) {
    // block full, get new block
    getNextBlock();
  }
}
```
Refactoring it now so `Block` is gone, but keeping `WritableBlockChannel`.  With this change, could be simple to add the function that produces this to `BlockHandler`.  

There are a few issues I have with `BlockHandler` when it comes to client API and reusing on remote write path.

1) API requires that the client maintain the position state.  If the user messes this up, or makes assumptions that it can be used when it can't (implement append?), then this will cause issues.  One example is that the user tries to write at offset 50, then at offset 0.  The current API is fine with that and will work ok with the local impls (maybe?) but causes out of order issues that I need to prevent on the server side.
2) There is no abstraction of where the block lives other than path, which implies that its a UNIX path.  More thought would be required to see how to make this work for remote (URI could work).
3) From the API, its unclear when read or write will fail.  If you try to write to a block that exists, what happens (from a API, not code), if you try to read from a block that doesn't exist, what happens?