- The ctx was already being passed between the different methods
  within the query pipeline, but the context was never being inspected
  to see if it had been canceled. This commit fixes that.
- Now when an error occurs, whether that error is local or on a remote
  peer, the request is immediately canceled.
- if the client disconnects before a response is returned (whether
  that is due to a timeout or the client canceling the request), that
  cancelation will propagate throught and abort any work.

limit the number of getTargetsLocal threads that can be running at
once. This ensures that if a large query that spans 1000s of series
is executed, 1000s of goroutines wont be run at once to hit the
caches and cassandra.
This also ensures that a single query cant fill the cassandra
read queue.  Mt only executes cassandra-read-concurrency requests
at a time so requests will always need to be queued. With this new
approach multiple render requests will share read queue and their
read requests will be interspaced in the queue, rather then the old
behaviour where a render request would have to complete all of its
reads before the next render request would be processed.

Overall this will lead to a more consistant performance profile
for render requests.

- the functions that spawn background work in new goroutines should
  be responsible for signalling to them that they should shutdown.
  So these functions should create a context.WithCancel and call cancel
  when the the first error is encounted.

- Instead of calling panic and having to recover the panic later,
  just pass errors throught the data fetch (getTargets) pipeline.
  This allows us to correctly cancel requests via the request
  context.

* no need to wrap an if err clause around s.getSeriesFixed(), as the
  output is always correct (in particular, when it returns an error, the
  series is nil)
* add consolidation.ConsolidateContext() wrapper so that the caller
  doesn't need to check the context prior to a call to
  consolidation.Consolidate()
* ditto for divideContext() -> divide()
* ditto for getSeriesFixed, except it doesn't need a wrapper, it was
  already checking the ctx.Done for most of its work (but not all)