Ensure that expression are not stale in operations

We should implement the `ensure_freshness` mechanism in c++.

My approach would be to replace the direct access to `pg` and `i` when building expressions by accessors in which we check that the computation graph of the expression is not dead.

Example :

Expression min(const Expression& x, const Expression& y) {
return Expression(x.pg, x.pg->add_function({x.i, y.i}));
}

becomes

Expression min(const Expression& x, const Expression& y) {
return Expression(x.pg(), x.pg()->add_function({x.i(), y.i()}));
}

Where `pg()` and `i()` can throw exceptions. Of course this will have a small overhead but it will prevent segfaults when using stale expressions.

Also once this is done we can remove `ensure_freshness` in python

Start by locating C++ Expression operations that directly access `pg` and `i`, then trace the existing `ensure_freshness` mechanism. Check how stale computation graphs are detected and how the proposed `pg()` and `i()` accessors would affect expression construction. Done means operations use freshness-checked accessors and the Python `ensure_freshness` implementation can be removed without leaving stale-expression crashes.

Written by the indexing model from the issue text.