Make MEM_WRAP_CHECK more compile-time
MEM_WRAP_CHECK(n,t) checks whether n * sizeof(t) exceeds the
memory size, and so is likely to wrap.
When the type of n is small (e.g. a U8), you used to get compiler warnings
about a comparison always being true. This was avoided by adding 0.0. Now
Coverity complains that you're doing a floating-point comparison with the
results of an integer division.
Instead of adding 0.0, instead add some more compile-time checks
that will cause the runtime check to be skipped when the maximum value
of n (as determined by sizeof(n)) is a lot less than memory size.
On my 64-bit system this also pleasingly makes the executable 8384 bytes
smaller, implying that in many cases, the run-time check is now being
skipped.

Bump Locale-Codes from 3.33 to 3.34
The core modules Locale::Country, Locale::Language, and Locale::Currency (all
part of the Locale-Codes distribution) should be updated on a regular basis.
They contain "codes" from various Internet standards which change over time.

[perl #123947] deparse $#_ as $#_ not as $#{_}
8c2e27d changed B::Deparse to deparse $#{1} as that instead of as $#1
which is a syntax error, but also changed $#_ to deparse as $#{_}
which isn't necessary, and broke GFUJI/macro-0.06.tar.gz
This could be considered a bug in macro.pm, but since we don't need to
deparse $#_ as $#{_} let's not do that.

[perl #123849] sv.c: Fix sv_clear -Do output
We try to print ‘sv_clear clearing PL_stashcache for '%"SVf"'’, but
the sv here is a hash, and we can’t do SvPV on it. We need the hash’s
name. This has been this way since 103f5a36127.

[perl #123955] Fix assert fail with 0 s/// in quotes
This is related to bug #123617 and is a follow-up to eabab8bcc.
This code:
"@0{0s 000";eval"$"
begins tokenisation as follows:
stringify ( join ( $ " , @ 0 { 0 subst
When seeing the subst after the 0, the parser discards many tokens and
we end up at the ; outside the quotes.
Since PL_lex_stuff (the temporary spot for storing the contents of a
quote-like operator) is localised as of eabab8bcc, we end up with just
PL_sublex_info.repl (the temporary spot for storing the replacement
part) set. Since it is still set when we get to the next double-
quote, it is treated as a two-part quote-like operator, like y or s.
That can’t happen, and we have assertions to make sure of it.
We need to localise PL_sublex_info.repl as well, so it gets freed
properly when scopes are popped after an error.

[perl #123848] Allow OPpTARGET_MY on qr
// in the scope of lexical $_ gets the OPpTARGET_MY flag set. If it
is used as an operand to smartmatch, it gets converted to a qr op.
There is no need to turn off the flag, since it is harmless at run
time. But we need to allow the flag on this op type to avoid asser-
tion failures when it is freed.

[perl #123821] Fix assert fail with \(&$0)=0
If the operand of a reference constructor that is assigned to is not
valid, then S_lvref (in op.c) queues an error and does not bother to
convert the op into an lvref op. This causes problems, since we have
already set lvref-specific flags on the op in the expectation that its
type will change. We get assertion failures later when freeing the
op, because of the invalid flags.
Instead of bailing out when we have an error like this, just continue
processing it, as we do in many other places.

[perl #123817] Assert fail with attr in anon hash
These two one-liners were failing an assertion:
$y = { my $x : m }
$y = [ (my $x : m) ]
The lexical with an attribute was turning into an op of type ‘list’
with the OPpLVAL_INTRO flag set. Many op constructors convert an
operand that is of type ‘list’ into the correct type, instead of
creating a new op to wrap around it. Other ops were not expecting the
flag to be set, causing an assertion failure. The easiest solution is
to turn off the flag in op_convert_list, which is where the op type
changes. (I tried modifying other op types to accept the flag, but
that caused problems for B::Deparse, which inquires of B::Op_private
which ops can legitimately take that flag.)

[perl #123802] Assertion failure with "\L\L"
This is a follow-up to f4460c6f7a. The check to see whether we are
in a quote-like operator needs to come before the call to sublex_done,
as sublex_done is just as problematic as doing SvIVX on a PV. (See
479ae48e22f for details on why.) Checking the type of PL_linestr is
not a reliable way to see whether we are in a quote-like op, so use
PL_in_what instead.

[perl #123763] Clear target on my $_; split
If a lexical $_ is in scope, then the first argument to split, which
starts out as a match op, will get the pad offset of $_ as its target,
since that’s how implicit lexical $_=~ usually works.
ck_split changes that first argument to a pushre op. The target
was not being cleared. That did not cause any problems, until
v5.21.4-408-gfd017c0, which optimised lexical @array = split to write
to split @array directly, by storing making lexical array’s pad offset
the pushre’s target.
You can see the obvious conflict there. We end up trying to split to
$_, which is not an array. On a debugging build, you get an assertion
failure when trying to extend $_. Make the split list long enough,
and you get a crash on non-debugging builds.
debugging$ ./miniperl -e 'my $_; split'
Use of my $_ is experimental at -e line 1.
Assertion failed: (SvTYPE(av) == SVt_PVAV), function Perl_av_extend, file av.c, line 70.
non-debugging$ ./miniperl -e 'my $_; split //, "a"x100000'
Use of my $_ is experimental at -e line 1.
Segmentation fault: 11