Simplify StrictRule due to transform up

### Description

The implementation of StrictRule used to replaces the children with `DummyLeafExec` s so they become inaccessible afterward.

But there exists a conflict that `LegacyOffload` applies each rule with `transformUp`.
```
class LegacyOffload(rules: Seq[OffloadSingleNode]) extends Rule[SparkPlan] with LogLevelUtil {
def apply(plan: SparkPlan): SparkPlan = {
val out =
rules.foldLeft(plan)((p, rule) => p.transformUp { case p => rule.offload(p) })
out
}
}
```
In other words, the class `DummyLeafExec` is invalid due to the mechanism of `transformUp`.

Take an example, a `ProjectExec` has a child `FileSourceScanExec`. The `StrictRule` will transform `FileSourceScanExec` to `FileSourceScanExecTransformer` and then transform `ProjectExec` to `ProjectExecTransformer` due to `transformUp`.

When hiding the children of `ProjectExec`, the child of `ProjectExec` already be the `ProjectExecTransformer`, so `StrictRule` can't hide anything.

### Gluten version

main branch

Start by reading the StrictRule and LegacyOffload implementations and tracing how transformUp visits SparkPlan nodes. Confirm how ProjectExec and FileSourceScanExec are transformed, then simplify StrictRule so child hiding is no longer invalid under transformUp; done means the offload transformations retain their intended behavior without relying on DummyLeafExec.

Written by the indexing model from the issue text.