Support targets of the form 'android-#' for android_binary

Summary:
Pulled the regex out of AndroidPlatformTarget.getTargetForId() and modified it
to work for both 'Google Inc.:Google APIs:-#' and 'android-#' forms. The code
that finds the additional Google jars is skipped if the target is 'android-#'.
Added unit tests to test the modified regex and the modified code in
getTargetForId(). Closes #118

Test Plan:
Run `buck build hello` and verify that the build succeeds. Then replace 'Google
Inc.:Google APIs:16' with 'android-16' in fbandroid/apps/samples/hello/BUCK,
run `buck build hello`, and verify that the build succeeds.
Move the JavaBinaryBuilder to use the AbstractBuilder

Summary: Helps make the code a little more consistent.

Test Plan: buck test --all
Add a flag to allow manifests to not be merged when building a java_binary.

Summary:
There are a tiny number of legitmate cases where merging the manifests of a set of inputs
to java_binary is not the right thing to do. Support those cases with an undocumented flag
that defaults to "true".

Closes #87 and fixes #86 on GH.

Test Plan: buck test --all
DefaultJavaLibrary's exported deps must be JavaLibrary instances

Summary:
The ##exported_deps## parameter for java library rules is documented
as a way to automatically add rules to the classpath for dependents
and so doesn't make sense for non-java library rules.  This diff adds
an error message if the user uses it for other rule types.

Test Plan:
- ant test
- included test
The CleanCommand does not need to extend AbstractCommandRunner.

Summary:
Stop using inheritance when it's not needed. This change will mean that only those commands that
need to know about BuildRuleTypes now depend on AbstractCommandRunner, which means it's possible
to hook in a step building extensions before building the "official" target graph without
impacting the clean-up times.

Test Plan:
buck test --all
buck clean
Resolve a lint warning about immutable return values.

Summary:
We don't expect callers to try and change the executable command returned from a BinaryBuildRule,
and as such we should mark the return value as being an `ImmutableList` rather than a plain
`List`.

Test Plan: buck build buck
Assert that the empty TestSelectionList includes everything

Summary:
Adding in a missing test -- we should test that the empty
`TestSelectionList` does indeed default to being inclusive.  If no
test-selectors are in play, everything is tested!

Test Plan: Run the test.
Using fake javac in external javac with zip test

Summary:
instead of using the systems javac in the unit test we use a fake javac
that fails when it gets a zip file passed.

Test Plan: ##buck test --all##
Introduce a Repository abstraction.

Summary:
One of the planned changes to Buck is the introduction of "cross-repo targets". These are
targets that allow building of targets from other (buck-ified) projects that are checked
out "elsewhere" on the filesystem. As an example, perhaps you have a suite of common
library functions checked out under "/src/common" and your project under "/src/project".
A cross-repo target would allow a target in "/src/project" to refer to a target in
"/src/common".

This introduces a Repository abstraction upon which we can start iterating the
implementation of these targets. I suspect we're missing a "Repositories" abstraction too,
but baby steps.

Test Plan: buck test --all
Kill AbstractBuildable.AnonymousBuildRule, since it's the same as a DescribedBuildRule.

Test Plan: buck test --all
Move DescribedRuleTest.ensureThatSpecifyingZeroIsNotConsideredAbsent() ...

Summary: ... to ConstructorArgMarshallerTest where it really belongs.

Test Plan: buck test --all
Push the BuildTarget that invoked a java compilation through as a BuildTarget

Summary: Death to Stringly-typed code.

Test Plan: buck test --all
Add unit tests for TargetNode.

Test Plan: buck test --all
Make buck.py PEP8 compliant

Summary: This file was generating quite a few PEP8 lint errors.

Test Plan: ant test
Buildable.getBuildSteps returns an ImmutableList<Step>

Summary:
This refactors ##Buildable.getBuildSteps## to return a ##ImmutableList<Step>##
instead of a ##List<Step>##.  Along lines of D1361352, we don't expect the caller
to ever modify these and we are already making these all immutable to begin with.
Additionally, there are static analysis tools that warn on these cases, which this fixes.

Test Plan: ant test
Allow ConstructorArg instances to have Optional<Boolean> fields.

Summary:
We never needed them before, but we do now. Optional fields should default to None unless
they are a Collection type.

Test Plan:
Add new test
buck test --all
Test that exacerbates the NoTestsRemainException bug

Summary: A long standing issue with test filtering is that if you are
using a filter in JUnit and you encounter a class without any tests, an
exception is raised where one wouldn't normally be raised if filtering
was turned off.  This unit test will catch any regressions.

Test Plan: Run it!
Always use a JUnit filter, even if we don't have any test selectors

Summary: Always use an `org.junit.runner.manipulation.Filter` even if we
haven't been asked to do any filtering.  This means the filter code will
always execute.
List all tests when using --dry-run

Summary: The original `--dry-run` would list buck targets that would be
run for the given command line arguments.  Now, when using --dry-run,
each individual test (i.e. the test-method in the test-class) is listed
as a `DRY_RUN` test result on the event bus.  Console output is a bit
more terse, just listing the test classes and a summary of how many
tests will run for each class.

Test Plan:
```
lang=none, name=command line
$ buck test test/com/facebook/buck/graph/ --dry-run --output-events-to-file /tmp/events
...
MATCHING TEST RULES (1):

  //test/com/facebook/buck/graph:graph

DRYRUN <100ms  5 Passed   0 Skipped   0 Failed   com.facebook.buck.graph.AbstractAcyclicDepthFirstPostOrderTraversalTest
DRYRUN <100ms  2 Passed   0 Skipped   0 Failed   com.facebook.buck.graph.AbstractBottomUpTraversalTest
DRYRUN <100ms  1 Passed   0 Skipped   0 Failed   com.facebook.buck.graph.DotTest
DRYRUN <100ms  1 Passed   0 Skipped   0 Failed   com.facebook.buck.graph.HashMultimapTest
DRYRUN <100ms  7 Passed   0 Skipped   0 Failed   com.facebook.buck.graph.MutableDirectedGraphTest
TESTS PASSED
```

```
lang=json, name=/tmp/events
{
   "threadId" : 80,
   "timestamp" : 1401725614520,
   "nanoTime" : 1401725614520455000,
   "type" : "RunComplete",
   "buildId" : "6f822a79-503e-a17e-f04e-f5542b69382b",
   "results" : [
      {
         "success" : true,
         "testCases" : [
            {
               "success" : true,
               "testResults" : [
                  {
                     "stdErr" : "",
                     "stacktrace" : "",
                     "stdOut" : "",
                     "time" : 0,
                     "testName" : "testCycleExceptionDoesNotContainUnrelatedNodes",
                     "type" : "DRY_RUN",
                     "message" : ""
                  },
                  ...
               ],
               "failureCount" : 0,
               "totalTime" : 0,
               "testCaseName" : "com.facebook.buck.graph.AbstractAcyclicDepthFirstPostOrderTraversalTest"
            },
            ...
         ],
         "failureCount" : 0,
         "dependenciesPassTheirTests" : true
      }
   ]
}
```
Megadiff: Add missing dependency autodetection.

Summary:
What's going on here:
* Create the `SrcRootsFinder` class to help us find all the
  not-absolutely-specified source roots, so that we can find Java
  symbols that live in those places. The `FakeProjectFilesystem` is not
  currently capable of testing this class, so create `FakeDirectory` and
  plug it in to enable the test methods we need (specifically a
  `walkRelativeFileTree` method that actually visits directories).
* Create the `MissingSymbolsHandler` class to put together all the
  moving parts of dependency autodetection (the other major parts, already
  checked in, are `JavacErrorParser` and `JavaSymbolFinder`).
* Plug everything into a new event listener in Main.

Still TODO:
* Walking the whole project looking for src_roots directories isn't
  ideal. We will need a setting in .buckconfig to govern it, so that it
  doesn't get bogged down in massive projects. Perhaps when we have
  better side-by-side-project support, we can get rid of the floating
  src_roots concept and instead use separate .buckconfig files for third
  party projects?
* We don't currently respect visibility settings, so if we suggest a
  dependency that's not visible, you might not notice that until your
  next build gives you the nasty visibility warning.
* We also don't filter out duplicates -- multiple targets that provide the
  same missing symbols -- and if you add more than one you will get a
  warning at the end of the build.
* We don't currently detect missing dependencies when the symbol that's
  missing is in the same package as the source file that's missing it.
  This is because these symbols are usually referenced unqualified,
  without any import statement.  We should be able to make educated
  guesses to fix this case.

Test Plan: Lots of new unit and integration tests.