Remove last_saved_filename.

The implementation of draw_board_image() that updates a symlink to the latest
game board image doesn't need last_saved_filename, which was only used by the
index template to find the correct image to load.
Add points for controlling territory
Refactor TappyTerrorGame to own the game state

Changes TappyTerrorGame.game_board from a class object to an instance object
and hoists the things that need to muck with the game board into methods so
that it's clearer who's going to be able to muck with object state.
Make active_players and team_points instance variables
Initial db notes
Initial pass at state snapshot schema

First pass at moving the Tappy Terror state snapshots from disk into the db.
The general plan follows the outline previously in schema.sql.

I've split the data for locations and teams into tables for the data that
does not mutate over the course of a game and _ephemera tables for the data
that could potentially change every snapshot.

The _ephemera tables could use the sqlite 3.8 WITHOUT ROWID optimization if
desired, but the default sqlite3 on my dev system is 3.7.13 so I want it to
work without upgrading sqlite.
Cleanliness: drop indexes if they exist before creating
Separate game tests from web tests
Add missing foreign key constraints on team_ephemera
Implement equality operations for Location

In writing the snapshot to/from db, I had some tests fail because I hadn't
yet implemented __eq__ for Location. This adds __eq__, __neq__, and __hash__
for location so it can continue to be used as expected.
Correct spelling of vertices
Add missing DROP INDEX statement
Floor bounds data and team setup from HOPE
Snapshot game to database

Implements snapshotting the game to the database. The workhorses here are
the snapshot_to_db and load_from_snapshot functions which do the db work.

snapshot_to_db is fairly straightforward -- we record our snapshot time then
just insert the data from the instance into the _ephemera tables.

load_from_snapshot is a bit more complicated, mostly due to needing to
reconstruct the bounds from the Polygons. In retrospect, it might be more
straightforward to take a different tack and just make all the bounds load
separately from the _ephemera data.

In the end, this is theoretically more robust than the shelve/pickle approach
but I'm really unhappy with how much code it took to get this working.
Order the bounds_vertices lists

Adds list_rank to bounds_vertices so that the collections can be kept in
order. The vertex lists need to be in order for us to draw them correctly.
We can't actually guarantee that the query order from SQLite is the same as
the insert order, so this extra data helps us out.

This isn't actually normalized because I feel like we should not need to
reorder entries in the vertex lists.
Remove shelve code
Load database on flask requests

Configuration and before/teardown_request scaffolding for letting Flask access
the database. This will let flask requests get at game state snapshots.

Also update the Makefile to build tappy.db, the starting database.
Display game data in game template

Updates the game and index view to pass along the latest snapshot of the game
to the template. Also updates the template to display the data.

The template obviously still needs styling still but for now it will display
ugly but real data.
Merge branch 'statedb', bringing over the inital switch to databases

Bringing this over as its own commit so that it's a little easier to back out
if I decide that the advantages of using sqlite3 aren't worth the code overhead.