New Data layer

This reimplements `datadescriptors`. 

My experiences in #227 were that it was frustrating to change data descriptors because 

1.  They are tightly bound to the rest of the blaze array machinery
2.  They offer complex heterogeneous operations without a standard uniform interface
3.  There are a lot of them

I originally planned to standardize just a few within `datadescriptors`, but this caused a mismatch that led to lots of trouble.  It became clear that I was pulling on a very long thread.  My current solution is to reimplement `datadescriptors` in a new `data` directory. This directory holds six data descriptors

* Python
* DyND
* CSV
* JSON/JSON_Streaming
* HDF5
* SQL

Each of these can perform the following operations

*  `as_py` - dump data into memory as using core Python objects (list, dicts, strings, ints, ...)
*  `as_dynd` - dump data into memory as DyND array
*  `__iter__` - iterate over stream of data as Python objects
* `chunks` - iterate over chunks of data as DyND arrays
* `extend` - add Python objects into data store
* `extend_chunks` - add DyND arrays into data store.  

So each data descriptor can push their data to the others, either in a iterator/python user-facing way or in a chunked/dynd internal-efficient way.  Data in one format can be streamed to the other if the target supports the dshape.  That's really all that they do.  I'd like to build out `blaze.data` independently of the array machinery for a while and then perform a `datadescriptor` to `data` swap once we've settled on an interface.  I hope to get people using `blaze.data` on its own.

I recommend looking at https://github.com/mrocklin/blaze/blob/data/blaze/data/tests/test_interactions.py

The 10000 foot example is the following:

```Python
from blaze.data import *

source = resource('/path/to/data.*.json.gz', schema='{name: string, amount: int}')
dest = resource('postgresql://sql-uri::tablename', schema='{name: string, amount: int}')

iter(source)  # Python objects
source.chunks()  # DyND arrays (for future efficient computation)

copy(source, dest)  # move data
```

More explicitly we would do the following

```Python
from blaze.data import *

descriptor = partial(JSON_Streaming, open=gzip.open)
source = Files('/path/to/data.*.json.gz', descriptor, schema='{name: string, amount: int}')

# Use SQLAlchemy to set up table 'accounts' in database with proper schema
dest = SQL('postgresql://sql-uri', 'accounts', schema='{name: string, amount: int}')

# Crawl file system, gzip.open files, parse them from JSON into DyND arrays
chunks = source.chunks()

# Iterate over DyND arrays to Python objects, use SQLAlchemy to insert
dest.extend_chunks(chunks)
```