Eliminate route-based alias support

If success is found in serving some API endpoints as static JSON files,
then the idea of being able to associate route aliases on the routes
themselves will no longer work (since said routes will have been
replaced by non-alias-capable static file routes in the YAML
configuration).
Remove Python-based static API endpoints

Pulls out these endpoints in preparation for them to be replaced with
static files served using the CDN.
Initial pass at static-built API endpoints

This introduces a new "builder" module that is responsible for parsing
the data files at deploy time to build out many static JSON files to be
uploaded with the application. These files can be served up directly
from the Google CDN without ever spinning up a Python instance.
List sorting during deployment

When building out the static "list" endpoints, sorting can occur on the
'id' property so that these are produced in the same way each time since
the underlying "dict" structure does not guarantee order.
Custom sorting for static lists

Moves the sorting lambda from the builder module into the META
definition for each of the data modules, allowing each type to do its
own custom sorting.
Builder refactoring

Begins cleaning up the builder code in preparation of adding additional
functionality and also in preparation of breaking up into a package.
Builder as a whole package

Breaks all the builder code up into a package consisting of modules
dealing with configuration (__init__), building logic (__main__),
attribute values (attr), and writing the files (out).
Removal of custom routing table construction

Replaces the former custom routing table construction with a simpler
on-the-fly list comprehension and restores the original WSGIApplication
constructor.
Simplified JSON methods for dynamic endpoints

Now that all static data will be served up via the CDN, the underlying
JSON methods in the Response class can be much simpler -- we no longer
need to scan for internally-used keys.
Repurpose the 'lookup' meta data for regex

In its new use, this will be usable for automatically generating the
static routes in the app.yaml file. In addition, a tester has been added
to the builder to verify that all IDs in the LISTs match the given
'lookup' in the META.
Move lookup pattern checks to checker package

These are now more sophisticated, allowing for checking to see if
non-existent IDs would be allowed through by the regex.
Split patterns into lax and strict

When dealing with static data, the lax pattern can be used for matching
files on the local file system during uploads (e.g. static_files in
app.yaml) whereas the strict pattern can be used for making sure that
all endpoint requests are valid (e.g. url in app.yaml).
Prep builder package for app.yaml generation

Removes the app.yaml file from Grunt's copy task so that it can be done
by the builder package, where a new transform() function will be made
available to copy and regex substitute file contents.
Update clean rules

These now include the checker package.
Automatic generation of static application routing

Adds support to the builder package to automatically build the router
rules for the static API endpoints (both listing and detail endpoints).
Clean up of builder package

Renames constants to be consistent and fixes a hard-coded filename in
the out module.
Merge branch 'chg/web-api-cdn' into develop

Brings in the ability for all static data endpoints that do not depend
on external sources (e.g. live arrivals) or something dynamic (e.g. time
of day) to be served by the Google CDN rather than having to be routed
through a running Python instance.

The static endpoints are built at deploy time (or at "run" time when
using Grunt to test the static endpoints) using the "builder" package,
and some aspects of the static data can also be tested using the
"checker" package.

Conflicts:
	web/Gruntfile.js
	web/api/base.py