invoke rsync via open3

This allows the rsync command to be forked without any quoting issues
which arise through the existence of an intermediate shell process.
make --delete optional
factor out handling of temporary exclude file
rename paths to changed_paths
simplify structure of :excludes option values

The :excludes option expected a Hash whose keys were Regexps.  This
had a number of issues:

  1. It required iterating over the whole source tree to find which
     files matched; this could be costly if the tree is large.

  2. The values were expected to be nil, false, or Procs which would
     transform a matching file path into another file path to be
     excluded.  But this syntax is ugly when you just want to exclude
     a single thing, e.g.

       :excludes => { '.git' => false }

     and didn't actually buy anything useful, since the exclusions
     caused by calling the Proc could be equivalently achieved via
     another Regexp.

  3. It's counter-intuitive since most users already know rsync
     accepts *lists* of exclude patterns, not hashes.

Therefore we simply switch the exclude list to be an Array of native
rsync exclude patterns.  Later we can add back support for Regexps in
case the convenience afforded to the user outweighs the
Dir.glob('**/*') performance hit.
don't strip trailing slash from input path

This well-known rsync behaviour can be very useful in many situations,
so it doesn't make sense to intentionally cripple the way guard-rsync
wraps around it.
don't check that input path is a directory

It's a perfectly valid use case that the input path might be a single
file, or a shell-like expansion pattern (rsync will accept things like
"foo{1,2}").
allow caller to specify arbitrary excludes

This paves the way for graceful handling of removal events,
where the include/exclude list will be completely different.
allow supplying of arbitrary arguments to rsync
handle removals
make rsync -v optional
fix bug with guard group containing multiple Guard::Rsync guards

In a guard group containing n Guard::Rsync guards, if
:run_group_on_start is true, at start time each guard not only runs
itself but also the n-l other Guard::Rsync guards via the
::Guard.guards.each loop, resulting in a total of n^2 invocations of
run_all.  This is easily fixed by skipping any Guard::Rsync guards
inside the loop.
omit -v from rsync arguments during run_all

run_all is called less frequently, and unlike run_on_change etc., it
is not triggered by a listener event.  Therefore the deltas are likely
to be larger and the consequent output verbosity too high if -v is
used.
output the offending output parameter

If there are multiple guards, this makes it clearer which one failed.