`Wrapx`: Extending `Wrap` to cover more wrapper patterns.

Currently, Wrap is an object that can encapsulate all wrapping cases where one or several of the following happens:

signature changes
inputs are transformed
outputs are transformed (according to output of wrapped function only).

But this doesn't cover situations where the wrapped function call may need to be modified, or the output trans need to be controlled from the interface. For example:

wrapped function needs to be called in a subprocess
wrapped function needs to be "iterized" (i.e. we want to call it with map(func, ...) instead of just func(...)
output_trans is saving or logging the output and aspects of this (where it saves or logs) needs to be controlled from the outside

Following are some structural ideas for this extension of Wrap.

Sourcing from user input with `call_forgivingly`

    def __call__(self, *args, **kwargs):
        inner_input_dict = self.sig.kwargs_from_args_and_kwargs(args, kwargs)
        func_args, func_kwargs = call_forgivingly(self.ingress, **inner_input_dict)
        inner_output = call_forgivingly(self.func, *func_args, **func_kwargs)
        return call_forgivingly(self.egress, inner_output, **inner_input_dict)