Server exprs

closes #523 

Phil and I are playing with Blaze server.  Here is a raw query.

```Python
In [1]: from blaze.serve import Server

In [2]: from blaze import *

In [3]: csv = CSV('data/iris/iris.csv')

In [4]: csv.schema
Out[4]: dshape("{ SepalLength : ?float64, SepalWidth : ?float64, PetalLength : ?float64, PetalWidth : ?float64, Species : string }")

In [5]: server = Server({'iris': csv})

In [6]: server.app.run()
```

```Python

In [1]: from blaze import *
t = 
In [2]: t = TableSymbol('t', "{ SepalLength : ?float64, SepalWidth : ?float64, PetalLength : ?float64, PetalWidth : ?float64, Species : string }")

In [3]: from blaze.serve.server import to_tree

In [4]: expr = by(t, t.Species, t.PetalWidth.max())

In [5]: tree = to_tree(expr)

In [6]: tree
Out[6]: 
{'By': [{'TableSymbol': ['t',
    'var * { SepalLength : ?float64, SepalWidth : ?float64, PetalLength : ?float64, PetalWidth : ?float64, Species : string }',
    False]},
  {'Column': [{'TableSymbol': ['t',
      'var * { SepalLength : ?float64, SepalWidth : ?float64, PetalLength : ?float64, PetalWidth : ?float64, Species : string }',
      False]},
    'Species']},
  {'max': [{'Column': [{'TableSymbol': ['t',
        'var * { SepalLength : ?float64, SepalWidth : ?float64, PetalLength : ?float64, PetalWidth : ?float64, Species : string }',
        False]},
      'PetalWidth']}]}]}

In [7]: import requests

In [10]: r = requests.get('http://localhost:5000/compute/iris.json', data = json.dumps({'expr': tree}), headers={'Content-Type': 'application/json'})

In [12]: r.json()
Out[12]: 
{u'data': [[u'setosa', 0.6], [u'versicolor', 1.8], [u'virginica', 2.5]],
 u'datashape': u'var * { Species : string, PetalWidth_max : ?float64 }',
 u'name': u'iris'}
```

Note the format of `tree` above.  Note that it's not as complicated as it seems, most of the complexity is in repeated subexpressions (really just the tablesymbol).  Still, I think that this is challenging to produce manually without library support (e.g. `to_tree` function and Blaze expressions).  

Next step would be to make a client that handles the request bit automatically.  After that I think that parametrized expressions are valuable.

Update:  Here is remote interactive work from Python

```Python
In [1]: from blaze import *

In [2]: from blaze.serve.client import ExprClient

In [3]: t = TableSymbol('t', "{ SepalLength : ?float64, SepalWidth : ?float64, PetalLength : ?float64, PetalWidth : ?float64, Species : string }")

In [4]: ec = ExprClient('http://localhost:5000', 'iris')

In [5]: t = Table(ec)

In [6]: t
Out[6]: 
    SepalLength  SepalWidth  PetalLength  PetalWidth Species
0           5.1         3.5          1.4         0.2  setosa
1           4.9         3.0          1.4         0.2  setosa
2           4.7         3.2          1.3         0.2  setosa
3           4.6         3.1          1.5         0.2  setosa
4           5.0         3.6          1.4         0.2  setosa
5           5.4         3.9          1.7         0.4  setosa
6           4.6         3.4          1.4         0.3  setosa
7           5.0         3.4          1.5         0.2  setosa
8           4.4         2.9          1.4         0.2  setosa
9           4.9         3.1          1.5         0.1  setosa
...

In [7]: by(t, t.Species, min=t.SepalLength.min(), max=t.SepalLength.max())
Out[7]: 
      Species  max  min
0      setosa  5.8  4.3
1  versicolor  7.0  4.9
2   virginica  7.9  4.9
```

### TODO

- [x] add namespace kwarg to `to_tree` to form nicer embeddable trees from expressions
- [x] Consider changing shape of trees to `{'op': 'Classname', 'args': [recurse downwards on args]}`
- [x] Change docs.  Maybe use iris dataset, show server with requests, ExprClient, show use of `to_tree` to help create a query.
- [ ] Deprecate / delete old indexing server?
Maybe use this url http://flask.pocoo.org/docs/0.10/quickstart/#a-minimal-application instead of just linking to Flask, to emphasize how simple the app really is