`-defun' is like `-lambda', but with destructuring. To implement it, abstract
the arglist and form generation code of `-lambda' into separate functions.

Additional benefits of the refactoring are:

- `-lambda' (and by extension, `-defun') can now accept empty argument lists
- `-lambda' (and `-defun') no longer rebinds symbols (fixing the TODO)

Various declaration forms should be handled properly in `-defun'.

Motivation: when this is merged, `lsp-defun' can be made an alias for `-defun'.

- Add a `-defun' &rest example.
- `-defun': add (declare debug), making it debuggable

Refactor `dash--destructure-body' to handle declarations and docstrings itself,
meaning that more code can be shared between `-lambda' and `-defun'.

Refactor `dash--destructure-body' to add signatures to the docstring of BODY if
necessary. This means that docstrings for `-defun' and `-lambda', ... now
generate functions with proper signatures.

Add `-defmacro', which is like `-defun' but as a macro.

For &as bindings, don't generate input<n> parameters but use the names
in the corresponding functions directly.

(-lambda ((sym &as &DocumentSymbol :detail?))) -> (lambda (sym) (-let ...))

&as bindings would generate paramters for lists already. Now do the same
for destructured vectors, too.

For some reason, using `-let' in `dash--destructure-body' caused compile-errors
when running the tests. Use `let*' + manual destructuring instead, fixing the
error and making the test suite pass.

`-let*' generates less bytecode than `-let', even if otherwise equivalent,
because the latter is implemented in terms of the former, with many temporaries.
This is exacerbated when using dynamic binding, because all of those variables
also need to be bound dynamically.

Add a TODO note because this is an implementation detail; `-let' needs to be
optimized independently.

No longer generate a redundant nil in `-defun' and `-defmacro', if no docstring
is provided and the arglist doesn't use destructuring.

This was due to a bug in `dash--destructure-body' only triggered in that case
with NODOC=nil.

Use `def-body', as is used in `cl-defun', allowing `-defun' to be
debugged.

Before this PR, a `wrong-type-argument' error was issued if the match-form
wasn't of appropriate type. Restore this behavior by `signal'ing this way again
if the arglist is of incorrect type.

For `lambda', `declare' is ignored. Do the same in `-lambda', allowing a
`-lambda' that starts with `declare' to be debugged.

To implement this, extend `dash--decompose-defun-body' to take an optional
DECLARE? parameter that determines whether `declare' is supported in addition to
`interactive'.

Note that macros can still be `interactive'. This is consistent with
`cl-defmacro', which doesn't put the first `interactive' in `cl-block'.

It would be a waste of time to implement a proper edebug spec for it, since
`dash''s destructuring logic is very complex and extensible. In addition, this
would make extending `dash''s destructuring logic harder.

The input<n> temporaries used in the generated function's arglists are now
uninterned symbols, preventing users of `-defun', `-lambda', ... from accessing
them.

To implement this, a new intermediate step was added: `dash--parse-arglist'
extracts variable bindings from a given arglist, and `dash--destructure-arglist'
(formerly `dash--make-arglist') and `dash--destructure-body' now also take the
result of the first function. This needed because uninterned symbols need to be
communicated to these functions.

Additional benefits of the new intermediate step are that
`dash--destructure-body' no longer needs to know anything about how the arglist
looks like and that there is no part of `dash' needs to know anything about
`lambda', `defun', ... keywords.

As of the previous commit, `dash--matcher?' only has one user,
`dash--parse-arglist'. Refactor the former to now also do destructuring,
yielding a better API and reducing code, as `dash--as-matcher-variable' and
`dash--as-matcher-tail' could be eliminated.

`-let' treats [x &as] as destructuring a vector of two elements, `x' and `&as',
while `dash--as-matcher?' would treat it as x being destructured like the empty
vector. Fix that by constraining vector matchers to be of at least length 3.

As of shared arglist parsing refactoring, ARGLIST was only used to compute the
docstring. Remove DOC, and make ARGLIST in its place imply that a docstring is
to be generated.

(command-execute (lambda () (declare) (interactive))) works, so all declarations
must be parsed. This function now behaves similar to `macroexp-parse-body',
except that the last form is not treated as the body, so that (-lambda ()
(interactive)) works.

Abstract the common parts of `-defun', `-lambda', etc. into the new function,
`dash--defun'.

`help-add-fundoc-usage', from the pre-loaded `help' library, is more robust (it
properly handles quotes), so use that.

If a `defun' contains only a single string in the body, that string is
considered both result and docstring. Do the same for `-defun'. This patch also
makes that function parse a `-defun' whose body consists only of strings
correctly.

Add regression tests.

`dash--normalize-arglist' should wrap them in another list. Add a
regression test.

Only 3 examples are shown in the manual, so move the various cons adding
examples later since they are not helpful. As such, show an `interactive'
example, a Docstring result example and a square bracket args example.

Rename `example/add-cons' -> `example/interactive'.