This fixes a bug in _delete_existing_rows_txn which was introduced in #3435
(though it's been on matrix-org-hotfixes for *years*). This code is only called
when there is some sort of conflict the first time we try to persist an event,
so it only happens rarely. Still, the exceptions are annoying.

Fix client_reader worker being able to handle /context requests

This allows us to handle /context/ requests on the client_reader worker
without having to pull in all the various stream handlers (e.g.
precence, typing, pushers etc). The only thing the token gets used for
is pagination, and that ignores everything but the room portion of the
token.

Use deltas to calculate current state deltas

If we have a delta from the existing to new current state, then we can
reuse that rather than manually working it out by fetching both lots of
state.

Improve logging for exceptions when handling PDUs

Fixes and optimisations for resolve_state_groups

Remove redundant checks on room forgottenness

Speed up _calculate_state_delta

Logcontext fixes

Make client_reader support some more read only APIs

Add some measure blocks to persist_events

Fix some random logcontext leaks.

... to help us figure out where 40% of CPU is going

when we get an exception handling a federation PDU, log the whole stacktrace.

it's easier to create the new state group as a delta from the existing one.

(There's an outside chance this will help with
https://github.com/matrix-org/synapse/issues/3364)

First of all, fix the logic which looks for identical input state groups so
that we actually use them. This turned out to be most easily done by factoring
the relevant code out to a separate function so that we could do an early
return.

Secondly, avoid building the whole `conflicted_state` dict (which was only ever
used as a boolean flag).

Thirdly, replace the construction of the `state` dict (which mapped from keys
to events that set them), with an optimistic construction of the resolution
result assuming there will be no conflicts. This should be no slower than
building the old `state` dict, and:
  - in the conflicted case, we'll short-cut it, saving part of the work
  - in the unconflicted case, it saves rebuilding the resolution from the
    `state` dict.

Finally, do a couple of s/values/itervalues/.

Only get cached state from context in persist_event