[Data] Make Operator a thin shared base

[myandpr]

Description

Why this is needed:

This is the next PR in the #60312 logical plan migration stack.

After cleaning up logical-operator fields and _get_args, the shared Operator base still owns concrete _name / _input_dependencies storage through a constructor. That keeps the base contract tied to mutable storage even though LogicalOperator now provides its own frozen dataclass-backed fields.

This PR makes the shared base contract explicit before the later __repr__ / __str__, rule-cleanup, and equality/comparability steps. This removes the old shared storage model from the base class, so later cleanup PRs can reason about logical operator state through the public contract instead of working around _name / _input_dependencies ownership in Operator.

What this PR changes:

Makes Operator a thin shared base with no constructor-owned _name / _input_dependencies storage.

Operator now defines the public name / input_dependencies contract and its default methods use that public contract instead of touching _name / _input_dependencies directly.

LogicalOperator continues to provide the frozen dataclass-backed implementation of that contract.

PhysicalOperator remains stateful and keeps the existing physical execution behavior, but now owns the mutable name/dependency storage it needs instead of relying on shared Operator storage. This physical-side change is compatibility-only: physical operators are not being made immutable or dataclass-backed.

This PR does not make physical operators dataclasses or immutable, remove redundant __repr__ / __str__, clean up broader logical-rule special-casing, or change equality/comparability semantics. Those remain separate follow-ups in the current split plan.

Related issues

Part of #60312

Additional information

This PR corresponds to the shared Operator / LogicalOperator base-contract cleanup step in the current split plan.

Tests

• Ran targeted logical, physical-operator transform, operator-fusion, and state-export tests.
• Ran touched-file pre-commit checks.

Stack Plan

Done:

• PR-A: Add a default property implementation for LogicalOperator.name
• PR-B: Move logical output_dependencies handling out of logical operators
• PR-C: Make LogicalOperator an ABC with abstract num_outputs
• PR-D1: Convert one-to-one logical operators to frozen dataclasses
• PR-D2: Convert map logical operators to frozen dataclasses
• PR-D3: Convert all-to-all, join, read, and write logical operators to frozen dataclasses
• PR-D4: Convert remaining source logical operators to frozen dataclasses
• PR-Next-0: Convert the remaining concrete logical operators to frozen dataclasses
• PR-Next-1: Convert abstract logical operator classes to frozen dataclasses
• PR-Next-2: make logical-operator names derived by default
• PR-Next-3: deduplicate _apply_transform
• PR-Next-4: replace input_op: InitVar with a real input_dependencies field
• PR-Next-5: remove input_dependency on AbstractOneToOne
• PR-Next-6: clean up _get_args
• This PR: make Operator a thin shared base

Next:

• remove redundant __repr__ / __str__
• clean up special-casing in logical rules
• finalize equality / comparability work for #60312

[gemini-code-assist]

Code Review

This pull request refactors the Operator base class into an Abstract Base Class (ABC), making name and input_dependencies abstract properties and removing the base init method. Subclasses like PhysicalOperator now explicitly manage these attributes and implement the required properties. A potential issue was identified in the PhysicalOperator.input_dependencies setter, which fails to maintain bidirectional graph consistency by not updating the _output_dependencies of the input operators when dependencies are changed.

[cursor]

Cursor Bugbot has reviewed your changes and found 1 potential issue.

^{Reviewed by Cursor Bugbot for commit 8fcb1ad32089f75ef1fe5d6fdf5cf04a5f336a6e. Configure here.}