Allow drop_conflicts to handle non-bool returns from __eq__

[max-sixty]

From Claude:

---

When merging attributes with combine_attrs="drop_conflicts", objects whose __eq__ method returns non-bool values (e.g., numpy arrays) would raise ValueError due to ambiguous truth values. This PR fixes the issue by catching the ValueError and treating such comparisons as non-equivalent, causing the attribute to be dropped.

This fixes a regression introduced in #10726 where the merge logic started using direct equality comparisons that can fail for certain attribute types.

What's changed:

• Added try/except around equivalent() call in merge_attrs for the drop_conflicts case
• Added comprehensive test coverage for various non-bool __eq__ scenarios

Test coverage includes:

• Objects returning single-element numpy arrays (unambiguous)
• Objects returning empty numpy arrays (ambiguous)
• Objects returning multi-element numpy arrays (ambiguous)
• Regular numpy arrays as attribute values

[shoyer]

Let me give a few give a few concrete examples of pathological inputs to be sure we handle for attribute equivalence:

1. NumPy object arrays, e.g.,

x = np.array([None], dtype=object)
x[0] = np.arange(3)
y = np.array([None], dtype=object)
y[0] = np.arange(10, 13)

2. xarray.Dataset objects (which actually raises TypeError!):

x = xarray.Dataset({'foo': 1})
y = xarray.Dataset({'bar': 1})

3. Pandas series:

x = pd.Series([1, 2])
y = pd.Series([3, 4])

I think we should re-write equivalent to make it a little safer to use. My suggestion:

def equivalent(first: object, second: object) -> bool:
    if first is second:
        return True

    if isinstance(first, np.ndarray) and isinstance(second, np.ndarray):
        return np.array_equal(first, second, equal_nan=True)

    if isinstance(first, list) and isinstance(second, list):
        return list_equiv(first, second)

    result = first == second
    if not isinstance(result, bool):  # unhandled array-like values
        return False

    return result or (pd.isna(first) and pd.isna(second))  # valid for scalars


def equivalent_attrs(first: object, second: object) -> bool:
    try:
        return equivalent(first, second)
    except ValueError, TypeError:
        return False

Potentially we could make this is a little more aggressive by returning False if first and second have different types.

[max-sixty]

implemented that approach @shoyer . so quite small & simple code changes; lots of tests...

[shoyer]

Thanks @max-sixty (+ Claude!)

[max-sixty]

Thanks @max-sixty (+ Claude!)

yw!

was an interesting case study — I give it a 6/10.

one wrinkle is that our standards are higher than most! and these models are great at doing median code, but even with me overseeing them, it still took a few iterations to get to the standard we wanted...