prepare remote module caching for parallel fetching

Summary:
When peru starts to do parallel fetching, it's going to be
important that a remote module can fetch itself and its dependencies at
the same time. Previously we had functions in `resolver` that fetched and
merged imports, and the remote module would fetch itself before calling
those. This diff refactors all of that.

- Create `merge.py` to provide `merge_import_trees()`. See the large
  comment in that function for more about why its structured the way it
  is. `resolver.py` is no longer aware of anything about imports; its
  only job is now to resolve targets into trees (and occasionally
  module/rule objects).
- Refactor `LocalModule` to call `merge_import_trees`. Clean up some of
  the lastimports code while we're at it.
- Make `RemoteModule` responsible for fetching its own dependencies, so
  that we can parallelize this soon. `RemoteModule.get_tree` no longer
  caches the final unified tree; it only caches the result of the fetch.
  The rest is left to `merge_import_trees`. This has the nice side
  effect that changing a module's imports won't cause it to refetch.

Test Plan: Relying on existing integration test.

Reviewers: sean

Differential Revision: https://phabricator.buildinspace.com/D57
support lists of imports as well as maps

Summary:
The easiest way to represent imports is as a map, but sometimes you
want to import the same module more than once. (We particularly want this in
testing.) This diff adds support for lists of imports as well as maps. Those
look like this:

```
imports:
    - foo: path/
    - bar: path/
```

We also create the `Imports` data structure so that code outside the parser
doesn't need to worry about this distinction.

Closes https://github.com/buildinspace/peru/issues/38.

Test Plan: New unit tests.

Reviewers: sean

Differential Revision: https://phabricator.buildinspace.com/D60
add the 3.3-compatible asyncio library to third-party

Summary: We will use this to fetch remote modules in parallel.

Test Plan: `./scripts/validate_third_party.sh`

Reviewers: sean

Differential Revision: https://phabricator.buildinspace.com/D61
parallel plugin fetching

Summary:
Use Python 3.4's `asyncio` to do plugin fetching in parallel. Right
now we don't try to parallelize any build or cache operations; those are still
done in series to keep things simple. We also don't do anything fancy with the
console; fetches will still print as they go, though reups have been modified a
little to make sure their outputs don't interleave.

This revision drops support for Python 3.2. We use the backport of `asyncio`
to maintain support for 3.3.

Test Plan:
All existing tests are passing. Not yet sure how best to test
the parallelism.

Reviewers: sean

Differential Revision: https://phabricator.buildinspace.com/D58
add the --parallel option to limit simultaneous fetches

Summary:
Set the default limit to 10. Use an `asyncio` semaphore to limit the
parallelism. Docopt is wonderfully flexible with flag arguments, so the user
can write any one of `-p N`, `-pN`, `--parallel N`, or `--parallel=N`.

Test Plan:
Brief testing on my apartment wifi suggests that 10 is just as fast
as 15 for small GitHub repos. A Google search confirmed that 10 is pretty.

Reviewers: sean

Differential Revision: https://phabricator.buildinspace.com/D59