Caching datasets

A set of changes surrounding computing on datasets

1.  `Data`  is now `InteractiveSymbol`.  `Data` remains a user level function so the public API is unchanged.
2.  `Data('uri::/data/path')` creates `Data('uri').data.path`
3.  Because we now prefer working on database-like-things we also support computing on dicts of data resources
4.  The Server now accepts a single data resource, not a namespace.  However that single data resource can be a dict, which, by point 3, is now a valid computable-thing.  So the public API is unchanged
5.  We add a Cached Dataset thing holds a dataset and caches computations against it in a dict-like object.  This dict-like object can be a [`chest`](http://github.com/mrocklin/chest).

Example
------

```Python
In [1]: from blaze import *

# Setup
In [2]: df = pd.DataFrame([[1, 'Alice',   100],
                         [2, 'Bob',    -200],
                         [3, 'Charlie', 300],
                         [4, 'Denis',   400],
                         [5, 'Edith',  -500]], columns=['id', 'name', 'amount'])
In [3]: iris = resource('/home/mrocklin/workspace/blaze/blaze/examples/data/iris.csv')
In [4]: dset = CachedDataset({'df': df, 'iris': iris}, cache=dict())
In [5]: d = Data(dset)

# Do a little computation
In [6]: d.df.amount.mean()
Out[6]: 20.0

# We keep a cache of expression -> result
In [7]: dset.cache
Out[7]: {mean(_1.df.amount): 20.0}

In [8]: d.iris.species.distinct()
Out[8]: 
           species
0      Iris-setosa
1  Iris-versicolor
2   Iris-virginica

In [9]: dset.cache
Out[9]: 
{distinct(_1.iris.species): (u'Iris-setosa',  u'Iris-versicolor',  u'Iris-virginica'),
 mean(_1.df.amount): 20.0}
```

Of course, future computations of these same expressions are just dictionary lookups.

I haven't yet done any sort of use of intermediate results although, in principle at least, that shouldn't be hard.
I don't actually have strong thoughts on what the exact type should be.  If it was a list, Series, or ndarray all would be fine to me so I don't want to make a test that invalidates two of those choices.  I wouldn't want a future developer to receive an error if they choose a different concrete type.

Testing the value seems good though.  Test added.