Allow the visitor to visit a subset of its children instead of all of them.

Test Plan: Unit tests.
Deal with recursive symlinks in directory traversal in buck.py.

Summary:
Recently this file was changed to do a recursive traversal while following
symlinks, without dealing with recursive symlinks.

This diff deals with recursive symlinks by recording all visited paths, and
skipping the ones that have already been visited.
Moved Paths.transformFileToAbsolutePath to MorePaths.

Summary: No point in using java.nio.text.Paths in this one, so just moving it to the new utility class.

Test Plan: ant clean test
Create recursive symlink rather than storing it in version control.

Summary:
The presence of this recursive symlink was causing `ant lint` to yield
a warning, which is distracting.

Test Plan: Sandcastle builds.
Simplify switch statement in Project.java.

Test Plan: Unit tests
Prompt user to clean their buck directory.

Test Plan:
Buck build with garbage in my buckdir, verify I was prompted, verify if I cleaned
my dir cache hits worked, if I didn't there were no cache hits.
Fix a bug with PythonBinary where I returned the wrong subset of deps.

Test Plan:
Unit tests
Removed Paths.normalizePathSeparator and Paths.containsBackslash.

Summary:
This removes two methods from com.facebook.buck.util.Paths class, replacing
their usages with methods form MorePaths

Test Plan: ant clean test
Make com.facebook.buck.util.concurrent.MoreExecutors available to our JUnitRunner.

Summary:
BuckBlockJUnit4ClassRunner contains some copy/paste code from MoreExecutors because
our JUnit runner uses a restricted classpath. This diff refactors things to share
the MoreExecutors code with our JUnitRunner.

Also remove duplicate documentation in BuckBlockJUnit4ClassRunner.

Test Plan: Sandcastle builds.
Use Uninterruptibles in MoreFutures.isSuccess.

Summary:
Same behavior, but it's less code because Guava already handles the
interrupted state.

Test Plan: Unit.
Update NailGun.

Summary:
Update the version of NailGun that buckd uses to
https://github.com/martylamb/nailgun/commits/fcc24ecd63ead63f160e96f6a0640f6b4280f72d,
which uses a FixedThreadPool instead of CachedThreadPool to reduce the number of threads
that Buck uses and notifies blocked threads on client disconnection so that threads aren't leaked.

Test Plan:
0) buck test --all
1) buckd
2) buck build buck
3) buck build buck
4) check that buckd is using <70 threads
Don't offer to clean the repo if there are modified files; don't offer to clean if there is no .buckversion.
Replace InputRule with Path.

Summary:
Updated `ConcurrentMapFileHashCache` to use a `LoadingCache` to maintain the
mapping from `Path` to `HashCode`.

Previously, `InputRule` contained four fields (`File`, `BuildTarget`, `ListenableFuture`, `RuleKey`).
We had one of these for potentially every file in a project. That is a large potential for
wasted memory. The existence of `InputRule` also required us to persist some kludginess in
`BuildTarget`.

This diff removes the hacks from `BuildTarget` and reclaims potentially a ton of memory.
By using a `LoadingCache`, we do not have to worry about the same input file being sha1'd
multiple times. We can also stop passing around references to a pathResolver in many places
and rely on `Path` being a path relative to the project root.

Test Plan: Sandcastle builds.
Clean up `ant javadoc` to exclude tests and quickstart sample files.

Test Plan:
Ran `ant clean javadoc` and verified that there were no warnings or errors.
Then viewed `build/javadoc/index.html` in Google Chrome and verified it looks good.
Spruce up the documentation for Buck.

Summary:
* Update the home page to note that Buck is both an Android and a Java build tool.
* Document the `buck quickstart` and `buck query` commands.
* Rewrite the Quick Start page to use `buck quickstart`.
* Migrate the old Quick Start page to the "Manual Quick Start" page.
* Create some new macros for inserting hyperlinks in `__common.soy`.
* Wrote up an article titled "What Makes Buck so Fast?"

Test Plan: Inspected locally on http://localhost:9811/.
Update buckd consoles.

Summary:
Parsers and FileHashCaches are reused by multiple commands,
so need to have their consoles updated on each command so that they
can log to the current console.

Test Plan:
0) buck test --all
1) buckd
2) buck build -v 8 buck &> /dev/null
3) touch tmp
4) buck build -v 8 buck 2>&1 | head
5) check that 4 prints "Parser watched event ENTRY_MODIFY ... tmp"
Don't print empty lines to SimpleConsole.

Summary:
If an empty builder is passed to
SimpleConsoleEventBusListener.printLines return rather than printing
an empty line to the console.

Test Plan:
0) buck test --all
1) buckd
2) buck build buck
3) check that no empty lines are printed by 2
Ensure that the default timeout in .buckconfig works with @RunWith.

Summary:
The custom logic that we use to support a default timeout for tests in `.buckconfig`
relies on our ability to use a `BuckBlockJUnit4ClassRunner` in place of a
`BlockJUnit4ClassRunner` when running JUnit. Unfortunately, when `@RunWith`
is present, the code path to produce a `BlockJUnit4ClassRunner` is not exercised,
which means our `BuckBlockJUnit4ClassRunner` is not inserted, which means
that our default timeout is not enforced.

This diff modifies the `AllDefaultPossibilitiesBuilder` that is used to select the factory
that is used to produce a `Runner` (which may or may not be a `BlockJUnit4ClassRunner`).
When `@RunWith` is present, we now take the `Runner` that is produced as a result of the
`@RunWith` annotation and wrap it with a `DelegateRunnerWithTimeout` that enforces our
default timeout.

It does this by taking the `RunNotifier` passed by the client and wrapping it in a
`DelegateRunNotifier`, which is passed to the original `Runner`. Our `DelegateRunNotifier`
intercepts events from the original `Runner` and passes them on based on the state of
test execution relative to the default timeout from `.buckconfig`.

Unfortunately, the logic in our `DelegateRunnerWithTimeout`/`DelegateRunNotifier` is not
as airtight as the logic in our `BuckBlockJUnit4ClassRunner`, so we are not going to delete
our `BuckBlockJUnit4ClassRunner` codepath just yet.

Test Plan: RunWithDefaultTimeoutIntegrationTest.
Normalize All The Path Cache Keys

Summary:
Equivalent paths do not always hash equally. When used as
hash table keys, Paths need to be normalized and either absolute or
relative to the same directory. This change normalizes the Paths used
as hash keys in the DefaultFileHashCache to ensure the cache works as
intended.

Test Plan:
0) buckd
1) buck test --all
2) add a failing assertion to a test
3) buck test --all
4) ensure that step 3 fails
Reuse the ExecutorService in DelegateRunnerWithTimeout so all tests are run on the same thread.

Summary:
It appears that all tests that use `ShadowLooper` in Robolectric need to be started from
the same thread so that its `resetThreadLoopers()` method works as expected.

Test Plan:
Sandcastle builds.
I promise to write an integration test in a follow-up diff.