Slight refactor to improve boot performance on some Ruby
implementations (for now).

These should allow external code to run blocks of user code to do
"work", at a similar unit size to a web request, without needing to get
intimate with ActionDipatch.

See the rationale in the comment present in this patch.

Better English.

This method needs to ensure that if a change happens, it is going to be registered.
With this refactor suggested by @matthewd race conditions do not matter because if
no file is watched, nothing is done. And as long as some invocation sets the flag
to true, it will stay true.

The refactor leaves a race condition in which two simultaneous threads that watch
some of the files passed do the actual work in `any?`, whereas the mutex guaranteed
that was done at most once. But this is considered to be a better tradeoff.

listen is calling us from its own thread, we need to synchronize reads and writes to this flag.

A small rewrite in a last attempt at writing obvious and portable code
without manual string manipulation.

Note that Pathname#== uses string comparison on Windows, so if client
code passes "C:\foo" and "c:/foo/bar" the predicate won't see the
former is an ascendant of the latter. Risky business.

Whatever the inner loop selects, we already know is a descendant and
can be filtered out right away from dirs_sorted_by_nparts to skip
useless iterations.

This commit also bases everything on Pathname internally.

This is the implementation of the file update checker written
by Puneet Agarwal for GSoC 2015 (except for the tiny version
of the listen gem, which was 3.0.2 in the original patch).

Puneet's branch became too out of sync with upstream. This is
the final work in one single clean commit.

Credit goes in the first line using a convention understood
by the contrib app.