rebase -i: Commit only once when rewriting picks

The options passed to `do_pick` determine whether the picked commit will
be rewritten or not. If the commit gets rewritten, because the user
requested to edit the commit message for instance, let `pick_one` merely
apply the changes introduced by the commit and do not commit the
resulting tree yet. If the commit is replayed as is, leave it to
`pick_one` to recreate the commit (possibly by fast-forwarding the
head). This makes it easier to combine git-commit options like `--edit`
and `--amend` in `do_pick` because git-cherry-pick does not support
`--amend`.

In the case of `--edit`, do not `exit_with_patch` but assign `rewrite`
to pick the changes with `-n`. If the pick conflicts, no commit is
created which we would have to amend when continuing the rebase. To
complete the pick after the conflicts are resolved the user just resumes
with `git rebase --continue`.

If `rebase--interactive` is used to rebase a complete branch onto some
head, `rebase` creates a sentinel commit that requires special treatment
by `do_pick`. Do not finalize the pick here either because its commit
message can be altered as for any other pick. Since the orphaned root
commit gets a temporary parent, it is always rewritten. Safely use the
rewrite infrastructure of `do_pick` to create the final commit.

squash! rebase -i: Commit only once when rewriting picks

git-commit lets the user edit the commit log message by default. We do
not want that default behaviour for the rewriting git-commit command
line. Pass `--no-edit` when rewriting a picked commit. An explicit
`--edit` passed to `do_pick` (for instance, when reword is executed)
enables the editor launch again.

TODO: Document the changed behaviour for root commit picks.
rebase -i: Do not die in do_pick

Since `do_pick` might be executed in a sub-shell (a modified author
environment for instance), calling `die` in `do_pick` has no effect but
exiting the sub-shell with a failure exit status. Moreover, if `do_pick`
is called while a squash or fixup is happening, `die_with_patch` will
discard `$squash_msg` as commit message. Indicate an error in `do_pick`
using return statements and properly kill the script at the call sites.
Remove unused commit message title argument from `do_pick`'s signature.
rebase -i: Prepare for squash in terms of do_pick --amend

Rewrite `squash` and `fixup` handling in `do_next` using the atomic
sequence

    pick_one
    commit

in order to test the correctness of a single `do_squash` or parametrized
`do_pick` and make the subsequent patch reimplementing `squash` in terms
of such a single function more readable.

Might be squashed into the subsequent commit.
rebase -i: Teach do_pick the options --amend and --file

The to-do list command `squash` and its close relative `fixup` replay
the changes of a commit like `pick` but do not recreate the commit.
Instead they replace the previous commit with a new commit that also
introduces the changes of the squashed commit. This is roughly like
cherry-picking without committing and using git-commit to amend the
previous commit.

The to-do list

    pick   a Some changes
    squash b Some more changes

gets translated into the sequence of git commands

    git cherry-pick a
    git cherry-pick -n b
    git commit --amend

and if `cherry-pick` supported `--amend` this would look even more like
the to-do list it is based on

    git cherry-pick a
    git cherry-pick --amend b.

Since `do_pick` takes care of `pick` entries and the above suggests
`squash` as an alias for `pick --amend`, teach `do_pick` to handle the
option `--amend` and reimplement `squash` in terms of `do_pick --amend`.
Also teach it the option `--file` which is used to specify `$squash_msg`
as commit message.

Both `--amend` and `--file` are commit rewriting options. If they are
encountered during options parsing, assign `rewrite` and pass `--amend`
(`--file` respectively) to the rewrite command. Be careful when
`--amend` is used to pick a root commit because HEAD might point to the
sentinel commit but there is still nothing to amend. Be sure to
initialize `$amend` so that commits are squashed even when `rebase` is
interrupted for resolving conflicts. It is not a mistake to do the
initialization regardless of any conflicts because `$amend` is always
cleared before the next to-do item is processed.
rebase -i: Teach do_pick the option --reset-author

`do_pick` is the git-cherry-pick wrapper in git-rebase--interactive that
used to implement the to-do list commands `pick`, `reword`, `squash` and
`fixup`. To cater for the different pick behaviours, `do_pick` accepts
several options not only from the git-cherry-pick but also the
git-commit interface.

Add `--reset-author` to the options pool of `do_pick`. It rewrites the
author date and name of the picked commit to match the committer date
and name.

If `--reset-author` is passed to `do_pick`, set the `rewrite` flag and
relay the option to the git-commit command line which creates the commit
after the picked changes are applied to the working directory and index.
If `--reset-author` is passed without `--amend`, the fresh authorship
effect is achieved by the mere fact that we are creating a new commit.
rebase -i: Teach do_pick the option --gpg-sign

`do_pick` is the git-cherry-pick wrapper in git-rebase--interactive that
used to implement the to-do list commands `pick`, `reword`, `squash` and
`fixup`. To cater for the different pick behaviours, `do_pick` accepts
several options not only from the git-cherry-pick but also the
git-commit interface.

Add `--gpg-sign` to the options pool of `do_pick`. It appends a GPG
signature to the commit object.

If `--gpg-sign` is passed to `do_pick`, set the `rewrite` flag and relay
the option to the git-commit command line which creates the commit after
the picked changes are applied to the working directory and index.
rebase -i: Handle rebase option --gpg-sign in do_pick

If `--gpg-sign` is passed to git-rebase, all replayed commits are
GPG-signed. In interactive mode, pretend `--gpg-sign` is passed to every
to-do list command by relaying `gpg_sign_opt` to `do_pick` in `do_next`.
`gpg_sign_opt` is either of the format `-S` or `-S<keyid>` which are
both supported by `do_pick`.
rebase -i: Teach do_pick the option --signoff

`do_pick` is the git-cherry-pick wrapper in git-rebase--interactive that
used to implement the to-do list commands `pick`, `reword`, `squash` and
`fixup`. To cater for the different pick behaviours, `do_pick` accepts
several options not only from the git-cherry-pick but also the
git-commit interface.

Add `--signoff` to the options pool of `do_pick`. It appends a
Signed-off-by: line using the committer identity to the log message of
the picked commit.

If `--signoff` is passed to `do_pick`, set the `rewrite` flag and relay
the option to the git-commit command line which creates the commit after
the picked changes are applied to the working directory and index.
rebase -i: Parse to-do list command line options

Read in to-do list lines as

    command args

instead of

    command sha1 rest

so that a to-do list command lines can contain additional arguments
apart from the commit hash and the log message title, which become the
non-options in `args`. Loop over `args`, put all options (an argument
beginning with a dash) in `opts`, stop the loop on the first non-option
and assign it to `sha1`. The loop does not know the options it parses so
that option arguments are not supported at the moment.

Print an error message for unknown or unsupported command line options,
which means an error for all specified options at the moment.

Ensure that the command line options read from the to-do list can
contain spaces and quotes by using git-rev-parse--sq-quote in
combination with eval.
rebase -i: Enable options for pick, reword and edit

pick, reword and edit are atomic to-do list commands in the sense that
they open a new task which is closed after the respective command is
completed. squash and fixup are not atomic. They create a new task which
is not completed until the last squash or fixup is processed.

Remove the `test -z "$opts"` blockade in front of the pick, reword and
edit handling code.

Enable the options `--signoff`, `--gpg-sign`, `--reset-author`, `--file`
(TODO: is not accepted because `do_next` cannot handle option
arguments), `--amend`, `--edit` for the to-do list commands pick, reword
and edit. squash and fixup still do not accept user options.