
TODO_26_08_72_06 clarify responsibilities and differences: interp vs delegator

This task is to think and see if FS_26_43_73_72 func tree interp (FT-interp) and delegator can
converge into a single building block.

Just to emphasise - the interp below is actually not any interp
(like FS_42_76_93_51 first/zero-ipos arg or FS_01_89_09_24 interp tree),
but FS_26_43_73_72 func tree interp (FT-interp).
In other words (in terms of upcoming FS_33_76_82_84 `composite_forest`):
*   irrelevant: `node_type: zero_arg_node`
*   irrelevant: `node_type: interp_tree_node` with `InterpTreeInterpFactory`
*   relevant: `node_type: interp_tree_node` with `FuncTreeInterpFactory` vs `node_type: func_tree_node` (delegator)

# Why do we need single-func `FuncTreeInterpFactory` interp instances?

All funcs are searched within the tree in a standard way:
*   args to the path within a tree can be specified out of order
*   all remaining args are eaten eagerly if possible (without re-querying)

For example, if `lay intercept goto` is specified, and there are some paths with the 2nd step `goto`,
this would select (based on how `intercept` is normally configured) no function - the user interrogation will stop.
This happens because there is no funcs with 1st step `intercept` and 2nd step `goto`.

By using FS_01_89_09_24 interp tree instead of FS_26_43_73_72 func tree,
`intercept` becomes terminal (single) function under interp tree with 1st step `intercept`,
so subsequent `goto` is consumed by next interpreter (which will start from beginning as FS_26_43_73_72 func tree).

It is a bit cumbersome to configure it, but it works as needed.
To be fair, there are not many meta functions like `intercept` or `help` (which also uses that).

# FT-interp vs delegator

Original diff:
*   FT-interp: searches func
*   delegator: searches func args

The original diff is straightforward:
*   FT-interp: func search is generic (regardless of the func)
*   delegator: func arg search is specific (depends on the func)

BUT(!): Isn't func search simply one more specific search (now to find a func)? Just like specific search to find func arg?

Interp searching func could really be just a delegator with a spec to find a func.

However, it is not that simple:
*   FT-interp: does not execute anything (no domain logic)
*   delegator: executes specific command (each delegator specializes on specific domain logic)

Why FT-interp and delegator seem need convergence?

Delegators for func like FS_88_66_66_73 `intercept`, FS_71_87_33_52 `help`, FS_02_25_41_81 `query`, ...
are trying to find another func as their arg.

And this jump from delegator back to FT-interp seems hacky.

Currently, the jump for these funcs even requires:
*   configuring separate delegators to specify `single_func_id`
*   configuring separate FT-interps for sub-trees to return to these as `tree_abs_path_to_interp_id`

This is related to TODO_10_72_28_05 (support `help` for any number of commands).
