Graph node (value + grad + backward fn)

The problem, from first principles

Backward for addition, Backward for multiplication and Backward for matmul each computed a LOCAL backward rule, given some upstream gradient, produce the gradient for each input, as a one-off function call. A real autograd engine needs more: it needs to remember, automatically, WHICH operations built which values, in what order, so that calling .backward() once, at the very end of a computation, can walk backward through every operation that happened and apply each one's local rule in the right order, without a human manually chaining the calls together.

This question builds the object that makes that possible: a graph NODE that doesn't just hold a number, it also remembers its own parents (what it was built from) and carries its own _backward function (how to push gradient into those parents), attached automatically the moment an operation creates it.

From theory to code

Theory wraps Backward for addition and Backward for multiplication's formulas into Value's __add__ and __mul__ operator overloads: each one builds a new Value recording its own parents, and attaches a _backward closure that, when called, applies that operation's backward formula and ACCUMULATES (not overwrites) gradient into each parent.

Implement Value.__add__ and Value.__mul__ against that reasoning. The class skeleton, __init__, and docstrings are already in the editor.

Constraints

• other may be a plain Python number, not just a Value, wrap it in Value(other) first.
• Gradient must ACCUMULATE (+=), never overwrite (=), a node used in more than one place needs contributions from every place it was used, added together.
• out._backward must be attached as a closure capturing self, other, and out (via Python's closure scoping, not passed as explicit arguments).

Hints

Open one at a time. Each gives away a little more than the last.