…tive method

A literal keyword argument is silently dropped (passed as a trailing
positional Hash) when the immediately-preceding statement is a `(...)`
argument-forwarding call to a native method that does not reset callInfo.
This raises a bogus `ArgumentError: wrong number of arguments (given 2,
expected 1)`.

The new test in test/jruby/test_call_info.rb fails on current HEAD and
documents the bug; the fix is described in the follow-up commit.

== Symptom (real world) ==

Found via sigstore-ruby on jruby 10.x HEAD. Sigstore::SBundle is a
DelegateClass; its #expected_tlog_entry(hashed_input, verifier_pem:) was
called as `bundle.expected_tlog_entry(hashed_input, verifier_pem:)` from
inside Verifier#find_rekor_entry, where verifier_pem was computed as
`signing_key&.public_to_pem || bundle.leaf_certificate&.to_pem`. The
keyword was dropped and the call raised ArgumentError. Switching the call
site from keyword to positional worked around it.

== Root cause ==

Two interacting pieces in the IR runtime:

1. org.jruby.runtime.Helpers#argsPush (Helpers.java:2334) and
   IRRuntimeHelpers#isHashEmpty / #irSplat set ThreadContext CALL_KEYWORD_EMPTY
   (1<<3) when a call is built with an *empty* keyword-rest. A Ruby >= 2.7
   `(...)` forward (which is what Forwardable#def_delegator generates, and
   what Certificate#to_pem -> OpenSSL is) builds the forwarded call with an
   empty `**` rest, so it sets CALL_KEYWORD_EMPTY.

2. IRRuntimeHelpers#setCallInfo (IRRuntimeHelpers.java:938-940):

       public static void setCallInfo(ThreadContext context, int flags) {
           // FIXME: This may propagate empty more than the current call? ...
           context.callInfo = (context.callInfo & CALL_KEYWORD_EMPTY) | flags;
       }

   It *preserves* a leftover CALL_KEYWORD_EMPTY bit into the next call's
   callInfo (there is already a FIXME about exactly this). callInfo is meant
   to be transient between a caller and its callee: the callee clears it in
   IRRuntimeHelpers#receiveKeywords via ThreadContext.resetCallInfo. But a
   *native* forward target (e.g. jruby-openssl's
   OpenSSL::X509::Certificate#to_pem, a generated $INVOKER$i$0$0$ method) has
   no IR recv_kw, so it never resets callInfo. The CALL_KEYWORD_EMPTY bit
   therefore survives the forward call.

When the very next call is a keyword call (CALL_KEYWORD, 1<<1), setCallInfo
ORs in CALL_KEYWORD while keeping the stale CALL_KEYWORD_EMPTY. In
receiveKeywords -> shouldHandleKwargs, `!keywordsEmpty(callInfo)` is then
false (the EMPTY bit is set), so keyword processing is skipped and the hash
is left as a trailing positional argument -> arity error.

== Diagnosis trail (verified by running, not guessed) ==

- Reproduces under `-X-C` (pure interpreter): an IR-runtime bug, not JIT.
- Caller IR is identical to passing cases: `call_2o(recv, arg, %hash, flags:2)`
  (flags 2 = CALL_KEYWORD). Callee IR is correct: recv_kw(acceptsKeywords:true),
  check_arity(required:1). So neither side is individually wrong.
- It is *not* receiver/class specific. A plain class with the same keyword
  method also fails when the call site is poisoned. The discriminator is the
  preceding value computation: a literal value passes; a value obtained from a
  `(...)` forward to a native method fails.
- Confirmed instrumenting Helpers#argsPush, IRRuntimeHelpers#{isHashEmpty,
  irSplat,setCallInfo} with prints: for the failing path argsPush sets EMPTY,
  then setCallInfo logs "preserving CALL_KEYWORD_EMPTY into CALL_KEYWORD call
  (prev=8 flags=...)" for the next keyword call. A passing path (e.g. forward
  to StringIO#string) shows callInfo already reset (prev=0) before that call.
- Only "first call" through a given `(...)` forward call site leaks; once the
  call site caches a non-array fast path it stops building the empty kwrest.
- jruby-openssl native methods (to_pem/to_der/version) trigger it; the core
  natives tried (String#upcase, Integer#even?, Array#length, StringIO#string,
  Digest#digest_length, BigDecimal#sign, ...) do not, because their dispatch
  leaves callInfo clean. So a fully gem-free repro needs `openssl` (bundled
  with JRuby); ~30 core/extension natives were tried and none reproduce.

== Minimal reproduction (gem-free; openssl ships with JRuby) ==

    require "openssl"
    cert = OpenSSL::X509::Certificate.new   # any signed cert
    def forward(o, ...) = o.to_pem(...)     # `(...)` forward to a native method
    def kwm(a, k: nil) = [a, k]
    v = forward(cert)
    kwm("HI", k: v)   # => ArgumentError: wrong number of arguments (given 2, expected 1)