Define and fully test the semantics of --ignore

[defuse]

--ignore has tricky semantics, see e.g. #35.

I think the intended behavior should be (this is NOT what it currently does)

1. the ignored path has to either exist in the original or backup (verified to exist, and be in either original or backup before starting),
2. the ignored path can either be relative to the roots being compared OR an absolute path OR a path relative to cwd. (Note: the two relative path cases are not mutually exclusive, we'd need to decide how to resolve that).
3. in either case (relative or absolute), the ignore applies to the opposite side, i.e. if --ignore /home/original/foo is ignored, this automatically ignores backup/foo and vice-versa
4. currently, report() does not ignore when the path given is the opposite side (I think?), but it probably should,
5. ignore gets checked first, so --ignoring unreadable stuff won't generate errors, and ignoring mount points won't generate DIFFERENT-FS messages.
6. with --follow, --ignore applies to the apparent path, not the actual path after symlink resolution (OPEN QUESTION: should it apply to the real path after symlink resolution, too? e.g. if original/foo -> original/abc and --ignore original/abc, does original/foo/x get ignored, or just original/abc/x? I think not because then before enumerating a directory we would have to understand every possible way it might be symlinked to, and there are probably examples where this would take exponential time to resolve, and it could lead to things being ignored by accident.)

Edit: See the comment in cli.rs; a lot of this has been fixed.

[defuse]

I'm satisfied that the current behavior is good enough for now. The only likely problems users might run into:

• expecting --ignore to be relative to the root rather than the cwd (currently, relative paths are only relative to cwd)
• report()ing reports even when the opposite side is --ignored.

The first case will give an error unless the user happens to be in either the original or backup directory, in which case it does the right thing. In the second case, the worst thing that will happen is it takes longer to run / reports more EXTRA/MISSING than expected, and it only occurs when you're ignoring a subdirectory of the thing that gets reported() since otherwise the ignore check in compare() catches it.