Remove OA_DANGEROUS from sort

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

pp_sort returns its arguments.  aassign_common_vars will check its kid
ops for danger as well, so it’s not necessary for sort itself to be
flagged this way.  This will allow cases like ($a,$b) = sort($c,$d) to
forego the temp copy.
Remove OA_DANGEROUS from grep and map

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

grep returns its arguments, while map returns the results of its first
expression.  Since aassign_common_vars, which does the danger check,
will also check the kids of the mapstart/grepstart ops, it is not nec-
essary for grep and map themselves to be flagged this way.
Remove OA_DANGEROUS from cond_expr

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

?: always returns one of its arguments.  Since aassign_common_vars,
which does the danger check, also checks the kids of the cond_expr op,
it is not necessary for cond_expr to be flagged this way.
Remove OA_DANGEROUS from die

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

die never returns, so it shouldn’t necessitate temp copies.
Remove OA_DANGEROUS from loopctl-type ops

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

These operators never return, so they shouldn’t necessitate
temp copies.

(This could probably apply to dump, too, but I don’t fully under-
stand dump.)
Remove OA_DANGEROUS from exit

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

exit usually doesn’t return.  When it fails, it returns a read-only
undef, so we don’t need temp copies for its sake.
tied is OA_DANGEROUS

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

tied returns the same scalar that the tied variables uses to hold a
reference to the object (so weaken(tied(...)) works).  tie uses the
very scalar that TIESCALAR (or TIEWHATEVER) returns and attaches it to
the tied variable by magic.  That returned scalar could be referenced
elsewhere.  That means

    ($a, $b) = ($c, tied $d)

could have common vars on either side, if the tie constructor for $d
happened to return $a or $b.  (Normally it would have to be an XSUB or
an lvalue sub for its return value not to have been copied.)
Fix ext/B/t tests after OA_DANGEROUS removals
enterwrite is not OA_DANGEROUS

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

‘write’ only ever returns a read-only true or false, so temp copies
are not necessary for its sake.
exec is not OA_DANGEROUS

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

When exec fails, it only ever returns a target unused elsewhere, so it
does not necessitate temp copies in list assignment.
kill is not OA_DANGEROUS

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

kill only ever returns a target unused elsewhere, so it does not
necessitate temp copies in list assignment.
smartkve.t doesn’t need to disable dep warnings
values and each are OA_DANGEROUS

OA_DANGEROUS indicates that temporary copies may need to be made in
list assignment, to handle things like:

($a, $b) = ($b, $a);

In other words, an op type is flagged with OA_DANGEROUS if its return
values could occur elsewhere on the stack.

values and each can both return scalars that are referenced elsewhere,
causing list assignment to behave erratically if temporary copies
are not made.
[Merge] More OA_DANGEROUS stuff

The OA_DANGEROUS op type flag indicates that an op might return a
value referenced elsewhere, so list assignment should make tempor-
ary copies.

Some ops had this flag needlessly.  Some lacked it erroneously,
resulting in bugs.