Add NestedResourceRouter

This commit adds routes.NestedResourceRouter.  It gives you a
convenient way to define a router in terms of nested resources:

    routes = (index_handler, {
        '0.1.0': (None, {
            'dogs': (dogs_handler, {
                '*': dog_handler,
             }),
            'cats': (None, {
                '*': cat_handler,
            }),
        })
    })

    router = routes.NestedResourceRouter(routes)

The routes format is defined as a recursive 2-tuple, starting
from the root of a path:

    route = (handler_for_root_resource, dict_of_child_routes)

For exmaple:

    child0_routes = (child0_handler, {}) # child has no children
    child1_routes = (child1_handler, {}) # child has no children

    (root_handler, {
            'child0': child0_routes,
            'child1': child1_routes,
        })

There is one bit of syntatic sugar, which is that passes a non-tuple
as a route is equivalent to an empty 2-tuple.  The following
are equivalent:

  routes0 = root_handler
  router0 = NestedResourceRouter(routes0)

  routes1 = (root_handler, {})
  router1 = NestedResourceRouter(routes1)

This router is partially formal RESTful, and partially convenience.
Specifically:

- REST has the idea of resources, upon which one operates with
  HTTP verbs.  This router gives you an easy way to designate
  resources, and map them verb-oriented handlers (specifically
  routers.method_router / routers.resource_descriptor_router).
  It takes you away from the idea of path matching, regexes,
  crazy DSLs.

- REST doesn't actually specify the idea of resource collections vs.
  resource items; they're all just resources--some resources just
  have different behavior than other resources when operated on.

- In practice the simplest way to think about resources and
  routing appears to be in terms of collections and item, so we're
  going to make the common case straightforward.

As usual, a router is really just a routing handler; it's a function
that, given a request, identifies some other request handling function
and delegates handling the request to that handler.  You can replace
this with any other variation of router that you want--it's just
a thing that figures out how to find and delegate to a handler.