@daft.method / @daft.method.batch silently ignore max_retries and on_error

[everettVT]

Summary

@daft.method and @daft.method.batch accept max_retries and on_error keyword arguments in their public signatures (`daft/udf/init.py:497-505`, `547-555`). `mark_cls_method` writes them to the method object as `MAX_RETRIES_ATTR` / `ON_ERROR_ATTR` (`daft/udf/udf_v2.py:409-410`).

But they're never read back. `Func._from_method` (`daft/udf/udf_v2.py:131-168`) reads `UNNEST_ATTR`, `BATCH_ATTR`, `BATCH_SIZE_ATTR`, and `RETURN_DTYPE_ATTR` from the method, but not `MAX_RETRIES_ATTR` / `ON_ERROR_ATTR` — it uses the values that `wrap_cls` passed in, which always come from the class-level `@daft.cls` decorator.

Result: a user who writes

```python
@daft.cls(max_retries=0)
class Pipeline:
@daft.method(max_retries=5, on_error="log")
def call_flaky_api(self, x): ...
```

gets `max_retries=0` and `on_error="raise"`, contrary to what the kwargs in the public signature suggest.

Expected

Either:

1. `Func._from_method` reads `MAX_RETRIES_ATTR` / `ON_ERROR_ATTR` from the method and uses them when set (preserving class-level defaults when unset), or
2. The kwargs are removed from the `@daft.method` / `@daft.method.batch` public signatures so callers don't think they work.

Option 1 matches the existing pattern for `unnest` / `batch_size` / `return_dtype` and matches what users are likely to expect (per-method override of class defaults).

Test gap

`tests/udf/test_cls.py` has no coverage for `max_retries` / `on_error` at all — class-level or per-method. Both should be added when this is fixed.

Doc impact

Docs in #6702 originally claimed per-method overrides worked; that has been corrected to flag the kwargs as currently no-op pending this fix.

[everettVT]

Minimum reproducible example (runs on the current main branch):

import daft


@daft.cls(max_retries=0)
class Flaky:
    def __init__(self):
        self.attempts = 0

    @daft.method(max_retries=3, on_error="log")
    def call(self, x: int) -> int:
        self.attempts += 1
        if self.attempts < 3:
            raise RuntimeError(f"transient failure (attempt {self.attempts})")
        return x * 2


flaky = Flaky()
df = daft.from_pydict({"x": [1]})

func = flaky.call
print(f"Func.max_retries = {func.max_retries}  (user passed 3 at @daft.method)")
print(f"Func.on_error    = {func.on_error!r}   (user passed 'log' at @daft.method)")

print(df.select(flaky.call(df["x"])).to_pydict())

Output under DAFT_RUNNER=native:

Func.max_retries = 0  (user passed 3 at @daft.method)
Func.on_error    = None   (user passed 'log' at @daft.method)
DaftCoreException: DaftError::ComputeError Error processing some rows:
0: DaftError::PyO3Error RuntimeError: transient failure (attempt 1)

The Func object returned by flaky.call carries max_retries=0 / on_error=None — the class-level values, not the ones the user passed to @daft.method. The call fails on attempt 1 instead of succeeding on attempt 3.

Root cause as reported: mark_cls_method writes MAX_RETRIES_ATTR / ON_ERROR_ATTR onto the method in daft/udf/udf_v2.py:409-410, but Func._from_method (daft/udf/udf_v2.py:131-168) only reads UNNEST_ATTR, BATCH_ATTR, BATCH_SIZE_ATTR, and RETURN_DTYPE_ATTR back. The retry attrs are written and never read.