Pull code that creates a comment on a pull request out of the
authorization check, and add tests around the authorization checks.

After pulling out the code that creates a comment, we still need to know
what the text of the comment will be, so change from a function that
returns a True on success and a False on failure to a function that
returns a True on success and raises an Exception (with the failure
comment) on failure.

Remove the free function `db_query` in favor of a `LockingDatabase`
class that wraps a database connection.

This is done so that, in order for a class to use the database, it only
needs its `db` instance, instead of needing both a `db` instance and a
`db_query` function.

This allows us to break out classes into separate files.

Extract PullReqState into its own file for code readability.

Because PullReqState shares some constants with main and server, extract
those constants into a `consts.py` file as well.

For some critical comments, Homu adds extra information about its state
in the form of a JSON blob to the comment that isn't visible to the user
but is visible in the source for the comment. For example, Homu may
leave a comment like the following, where the JSON blob is not visible
because of the `<!-- .. -->` markdown/html comments.

    ⌛ Trying commit abcdef with merge 012345...

    <!-- homu: {"type":"TryBuildStarted","head_sha":"abcdef","merge_sha":"012345"} -->

This change parses this extra information out of the comments and makes
it available to the initial synchronization algorithm.

Create the general structure for `process_event` and its testing, and
get a long way toward testing approval comments.

Break up the "status" field into multiple orthogonal state fields:

* build state (whether the primary is running or has succeeded or
  failed)
* try state (whether the most recent try is running or has succeeded or
  failed)
* approval state (whether the pull request is approved)

Previously (and still) these were mostly possible to determine by
looking at `state.get_status()` and `state.try_`, but storing them
separately helps make state changes more explicit.

Also, keep track of the current github synchronization cursor in the
pull request state, so that we can use it later.

Test that issuing a `@bors retry` command moves the state from 'pending'
to '' for pending pull requests. This is frequently used as a way to
yield the current build to a different pull request.

Homu creates a message when a try or build timeout occurs. Handle this
to keep the state properly updated.

Add more of the state to the Repository class, and make each
PullReqState reference it's Repository and get information from there.

Include a history of all of the tries and all of the builds when parsing
the history of a pull request.

Previously, we discretely set `status`, `try`, `build_state`, and
`try_state` on each event. With the addition of the run histories, we
can now glean all of this information from those histories instead of
tracking them independently.

The results appear to all be identical on the current Homu queue except
for one edge case: a pull request was tried, approved, then unapproved.

- Using the previous method, the status would be '', because approval
  changes the status from 'success (try)' to '', and unapproval doesn't
  change the status.

- Using the current method, the status would be 'success (try)', because
  a successful try has occured for the relevant commit hash and the PR
  isn't approved.