BUG: object and extension-dtype reductions honour skipna=False (GH-4147)

[jbrockmendel]

Stacked on GH-66507 (test-only, closes the five duplicate reports) — please review that
one first; this PR's diff assumes it. Supersedes GH-66471, which mixed the two and has
been closed.

GH-66507 covers the skipna=True half of object-dtype min/max, already fixed on
main by GH-65526. Writing those tests turned up four further defects in the same code
path, all of which are fixed here. References GH-4147 and GH-18588 for context; the
closing keywords live on GH-66507.

1. skipna=False on object dtype

_nanminmax gated the NA fill on dtype == object and skipna. With skipna=False the
_get_values fallback never builds a mask for object, so NAs went into the comparison
as-is. A float NaN propagates through a comparison on its own; an object NA does not:

>>> pd.Series(["a", None, "d"], dtype=object).min(skipna=False)
TypeError: '<=' not supported between instances of 'str' and 'float'
>>> pd.Series([1.0, np.nan, 3.0], dtype=object).max(skipna=False)   # wrong
3.0

Both now return a missing value. A reduction that covers the whole array short-circuits
to NA; a per-axis 2-D reduction blanks the NA-holding slices and nulls them through
_maybe_null_out. Values in a nulled slice are never compared, so they need not even be
comparable with each other — Series([1, "a", None], dtype=object).min(skipna=False) is
NA rather than a TypeError, while the NA-free Series([1, "a"]) still raises.

2. idxmin/idxmax on object dtype

nanargmin/nanargmax kept the ±inf fill, so they still raised on exactly the data
min/max now handles:

>>> pd.Series([date(2018, 1, 1), None, date(2018, 1, 3)]).idxmax()
TypeError: '>' not supported between instances of 'float' and 'datetime.date'

They now share _nanminmax's same-slice fill. _maybe_fix_arg_at_na needs no change:
if an argmin/argmax lands on a masked position, the fill must be at least as extreme as
every valid value, so it is the extremum, and it sits at the first unmasked position —
exactly what (~mask).argmax() returns. Verified by brute force against an NA-dropped
reference rather than by argument alone. With skipna=False they now raise the same
ValueError other dtypes do instead of TypeError.

3. sum/prod on object dtype

Same defect in nansum/nanprod: an object NA does not propagate through +/* the
way a float NaN does, so Series([2, None], dtype=object).sum(skipna=False) raised.

Note the asymmetry with min/max: NAs that do support the operation (pd.NA,
Decimal("NaN"), NaT) already propagate correctly and carry more type information
than a bare nan, so those are left alone — the natural reduction is attempted first and
the fill only steps in when it raises. Series([1, pd.NA, 3], dtype=object).sum(skipna=False)
stays <NA>.

4. skipna=False dropped by the groupby fallback

Dtypes with no Cython aggregation fall back to _agg_py_fallback → agg_series(ser, alt)
with alt=np.min, which has no way to receive skipna and silently dropped it:

>>> df = pd.DataFrame({"g": [1, 1], "v": pd.Series(["a", None], dtype="str")})
>>> df.groupby("g")["v"].min(skipna=False)   # wrong, expected NA
g
1    a

npfunc is now a closure that applies skipna. The same fallback backs
DataFrame.min(axis=1) on string columns, so that is fixed by the same change. Reach is
min/max for object/StringDtype/IntervalDtype/other EAs, prod for object and
EAs, and sum for EAs only — object sum has a Cython implementation and already
honoured skipna.

Verification

Beyond the suite: brute-force fuzz against an independent NA-dropped reference; a
systematic mutation sweep over every new source line (every surviving mutation closed and
re-checked); and a differential run of ~63k reduction calls against main with every
difference classified as intended-and-documented or investigated.

Not addressed

mean/std/var/sem on object with skipna=False still raise TypeError. Same
defect, but pre-existing and untouched here; worth a follow-up. Object string sum
with skipna=True also still raises, on the skipna=True path this PR does not modify.