Asynchronous solvers

So far all of our solvers are synchronous. They compute full results in lock-step, for example switching between performing a parallel mat-vec, then doing a line search, and then doing a mat-vec again. These algorithms are common on single-machine hardware but may not be ideal for larger clusters.

The distributed scheduler provides some decent capabilities for full asynchronous computing, which may open us up to new algorithms. Are there asynchronous variants to some of these algorithms that may interest us?

Quick example of asynchronous code:

```python
data_futures = client.map(load_chunk, chunks)
params = {...}

futures = client.map(compute_update, random.sample(100, data_futures), **params)

ac = as_completed(futures) # collection of running futures that yield in order of completion
for future in ac:
update_info, score = ac.result()
if is_good(score):
break
update_params(params, update_info)
new_future = client.submit(compute_update, random.choice(data_futures), **params)
ac.add(new_future)
```

@hussainsultan @mcg1969 @jcrist @moody-marlin

See Also
------

- [Convergence on repetitive data #31](https://github.com/dask/dask-glm/issues/31)