Clear weakened references when an array slot releases the last owner

[fglock]

Summary

Overwriting an array slot that holds the last strong reference does not clear
weakened references in PerlOnJava. This affects both the JVM and interpreter
backends and breaks Perl's observable weak-reference lifetime semantics.

Minimal reproducer

use strict;
use warnings;
use Scalar::Util qw(weaken);

my $object = bless {}, 'Thing';
my $weak = $object;
weaken($weak);

my @array = ($object);
undef $object;
$array[0] = undef;

print defined($weak) ? "retained\n" : "released\n";

Standard Perl prints released. Both PerlOnJava backends print retained.
The same problem occurs when the array is nested in a hash and when the array
reference is first copied into a local variable.

CPAN evidence

Algorithm::SlidingWindow 1.002 failed in CPAN tester run
20260827-171022-1876. Its pure-Perl reference-lifetime test passes under
standard Perl but fails under PerlOnJava:

• t/refs.t: obj1 freed after eviction (slot cleared) fails on the JVM
  backend.
• t/refs.t: obj2 freed after clear (slots cleared) fails on both backends.

The distribution stores values in a circular array buffer, explicitly replaces
evicted/cleared slots with undef, and expects that to promptly release the
last strong reference.

Expected behavior

When the final strong reference to a referent is removed through an array-slot
overwrite, any weak references to that referent must immediately become
undefined. This must be true for direct arrays, arrays reached through a hash,
and aliases to an array reference.

Suggested acceptance coverage

• Add project-owned regression tests for direct and nested array-slot
  replacement with undef after Scalar::Util::weaken.
• Cover circular-buffer eviction and clearing, matching the stable
  Algorithm::SlidingWindow scenarios.
• Run those tests on both JVM and interpreter backends.
• Ensure the release path continues to dispatch DESTROY correctly where the
  referent defines one.

[fglock]

Status after PR #1205 (c917973b5): this is still reproducible in the full distribution test.

timeout 900 ./jcpan -t Algorithm::SlidingWindow

t/basic.t .. ok
t/refs.t ... Failed 2/6 subtests
  4: obj1 freed after eviction (slot cleared)
  6: obj2 freed after clear (slots cleared)

Files=2, Tests=55, 2 failed
Result: FAIL
jcpan exit: 8

The minimal direct-array reproducer in this issue now prints released on system Perl, JVM, and interpreter, so it is no longer sufficient acceptance coverage. The remaining failure has the full Algorithm::SlidingWindow shape: a preallocated array ($#buf = $capacity - 1) stored by reference in a blessed hash, copied into a method-local $buf, and overwritten inside eviction/clear loops. Eviction also introduces method-local $item and $old scalars.

Required next steps

1. Add a permanent project-owned regression under src/test/resources/unit/refcount/ before changing runtime code. It should reproduce the distribution without depending on CPAN and cover these cases separately:

   • direct array-slot overwrite as the passing baseline;
   • a preallocated sparse/fixed-size array;
   • the array reference stored in a hash/blessed object;
   • a method-local alias (my $buf = $self->{_buf});
   • circular-buffer eviction with the same $item, $old, and $buf->[$head] = undef sequence;
   • looped clear() that writes undef to every occupied slot;
   • a referent with DESTROY, asserting prompt destruction, exactly-once dispatch, and weak-reference clearing.

2. Validate the new test with standard Perl first. Retain evidence that the focused eviction and clear assertions fail on the unfixed PerlOnJava parent, then require the same test to pass on both JVM and --interpreter backends. This is required regression coverage; an untracked reproducer or the broad CPAN test alone is not sufficient.

3. Reduce the failing project test one ownership layer at a time to identify the first transition from released to retained: preallocation, container nesting, local array-reference alias, method boundary, $old, $item, and loop iteration. This should distinguish a stale array-slot owner from a lexical/argument temporary that survives the method return.

4. Run the reduced failure with PJ_REFCOUNT_TRACE=1 and PJ_WEAKCLEAR_TRACE=1. Compare the owner/decrement timeline for the passing direct case and failing circular-buffer case. At the assertion boundary, identify every remaining counted/active owner of the evicted referent and the site that created it.

5. Audit the common ownership path used by both backends, especially:

   • RuntimeArray.get() and the element scalar returned as the lvalue;
   • RuntimeScalar.setLargeRefCounted() and refCountOwned when that lvalue is overwritten with undef;
   • RuntimeArray.elementsOwned / elementsAliased and markContainerOwner() for preallocated arrays reached through references;
   • MortalList.deferDecrementIfTracked() / flush timing;
   • method lexical and argument cleanup for $buf, $old, $item, and @_.

   The fix should retire only the actual strong edge being removed. Avoid a broad weak sweep or broad refcount drain: those can hide the stale owner and regress borrowed-reference lifetimes, DBIx::Class, or the recently fixed goto &sub cleanup behavior.

6. Acceptance gates after the fix:

   • focused regression: system Perl, JVM, and interpreter;
   • existing weak-reference/refcount/DESTROY suites on both backends;
   • timeout 900 ./jcpan -t Algorithm::SlidingWindow with all 55 tests passing;
   • full immutable make gate;
   • changelog entry under Work in progress.

Close this issue only after the tracked focused regression and the exact CPAN distribution test both pass on JVM and interpreter.