for pcase, require at least version 24.1 of Emacs

Sooner or later this had to happen.  While I would have preferred to
delay this move until after releasing version 2.1.0, it was always
clear, that I was only willing to maintain backward compatibility as
long as the cost was not very high.

Denying myself the use of `pcase' is such a cost.  I am going to use
this macro a lot, and while it would be possible to implement the
things to come without using `pcase', doing so would not be pleasant.
So unpleasant in fact, that the temptation would be big to write a
specialized "case" macro, similar to `magit-section-case'.  But my
experience with that, and `magit-section-action', has taught me that
going down that road leads to over-specialized abstractions which
eventually end up being rather featureful, but never-the-less to
restrictive even for its intended use-cases.
Merge branch 'n/pcase' into next
magit-file-status: new function

Note that `git status FILE' would cause tunnel vision - renames
would no longer be reported.  Also `git status' seems to never
actually report copies - and there is no argument or option to
force it to do so.
magit-discard-file: handle the various discard forms

Do not handle discarding an untracked file in `magit-discard', do it
in `magit-discard-file'.  Handle other, previously ignored, discard
variants too.  Get a file's status using the new `magit-file-status'
instead of relying on the incomplete information stored in the section
struct.
remove slot DIFF-STATUS of magit-section struct

Since the previous commit we don't use it anymore.
magit-untracked-section-map: don't bind magit-unstage
add magit-diff-{type,scope}, use for all apply dispatchers
add magit-discard-apply, use it when discarding any hunk or region
allow discarding just the un-/staged part of a file

Previously it was only possible to discard a file if it had either
staged or unstaged changes.  Remove that limitation.  Note that
discarding staged changes is done in two steps by first unstaging
and then applying the same changes in reverse to the worktree.
This second step can fail due to conflicts.
add option magit-no-confirm and function magit-confirm

Add it in most places where we previously used `yes-or-no-p'.  For
some of these, options existed to disable the confirmation; remove
these options `magit-stage-all-confirm', `magit-unstage-all-confirm',
and `magit-revert-confirm'.  In other cases it was previously not
possible to turn off confirmation.
magit-section: rename DIFF-SOURCE slot to SOURCE

and only set its value if it's different from that of slot VALUE.
magit-wash-diff: use " -> " as rename indicator

Previously we used " => ", now use what Git uses.
improve discarding of changes

I.e. (1) clearly separate it from "reversing" and "unstaging" and
(2) teach it about all the change units and sets a user might want
to discard.

Git doesn't know how to discard a change, so we have to use various
commands to implement this.  Require confirmation from the user for
each discard variant individually.  The variants are `delete' an
added file, `resurrect' a deleted file, undo a `rename', `discard'
an edit, and `resolve' a conflict by picking a side (and therefor
discarding the other).
rename magit-revert to magit-reverse

While both "revert" and "reverse" are used for some kind of "undo",
these actions are only somewhat related and definitely not the same.

While a `revert' Git command exists, there is no `reverse' command.
That term appears in form of the `--reverse' argument to the `apply'
command.

Because it is confusing that the command `magit-revert' does *not*
use or do the same thing as the command `git revert', rename it to
`magit-reverse', which makes sense because it ultimately ends up
using `git apply --reverse'.

Also move the definition of `magit-revert-commit' (which is Magit's
wrapper around `git revert') away from the `magit-reverse'.
magit-reverse: extend scope

Teach `magit-reverse' how to reverse multiple files (region and list),
at once.  Also teach it when reversing doesn't make sense: when the
change isn't tracked by Git throwing it away is enough.  The correct way
to make an unstaged change go away is to discard it, the correct way to
make an untracked file go away is to delete it (which is a variant of
discard).

Add new functions `magit-reverse-files` and `magit-reverse-apply', to
implement this.
magit-revert-{backup-file,undo}: move definitions
Merge branch 'n/apply' into next