Trying to simplify in/out path members

_I'm saving here some partial work for later and moving on._

### Context

#### How things are now:

```scala
trait AnyPath {

  type InC <: AnyContainer
  val  inC: InC
  type InT <: AnyGraphType
  val  inT: InT

  type OutC <: AnyContainer
  val  outC: OutC
  type OutT <: AnyGraphType
  val  outT: OutT
}

object paths {
  type InOf[P <: AnyPath] = P#InC#Of[P#InT]
  type OutOf[P <: AnyPath] = P#OutC#Of[P#OutT]

  def inOf[P <: AnyPath](p: P): InOf[P] = p.inC(p.inT)
  def outOf[P <: AnyPath](p: P): OutOf[P] = p.outC(p.outT)
}
```

i.e. first order members are in/out container and type, whereas their combination is derived separately.
**This approach works**, and it's important. 

But when `InT <: AnyContainerType` (i.e. `AnyContainer.Of[AnyGraphType]`) this approach becomes non-uniform, because you disassemble that nested type and work with its members (`AnyContainerType#Container` and `AnyContainerType#Of`). So I thought, if that works fine, why not to use the same approach in the `AnyPath` itself?

#### Here is what this branch is trying to do:

```scala
trait AnyPath {

  type In <: AnyContainerType
  val  in: In

  type InC = In#Container
  val  inC = in.container
  type InT = In#Of
  val  inT = in.of


  type Out <: AnyContainerType
  val  out: Out

  type OutC = Out#Container
  val  outC = out.container
  type OutT = Out#Of
  val  outT = out.of
}
```

i.e. `In` and `Out` become first-order members as container-types and their members are derived. This potentially leads to simplifications for defining steps and combinators. And the changes are not so big. But for finishing this we need to improve containers a bit, namely, for a particular `C <: AnyContainerType` to be able to express

- `C` with a particular type of container
- `C` with a particular type of Of
- `C` of a particular nested structure (e.g. two-level with particular containers)