¿Cuantificación limitada por F a través del tipo miembro en lugar del tipo parámetro?

Me gustaría mover un parámetro de tipo a un miembro de tipo.

Este es el punto de partida que funciona:

trait Sys[S <: Sys[S]] {
  type Tx
  type Id <: Identifier[S#Tx]
}

trait Identifier[Tx] {
  def dispose()(implicit tx: Tx): Unit
}

trait Test[S <: Sys[S]] {
  def id: S#Id
  def dispose()(implicit tx: S#Tx) {
    id.dispose()
  }
}

Lo que me molesta es que llevo un parámetro de tipo[S <: Sys[S]] a lo largo de mis bibliotecas enteras. Así que lo que estaba pensando es esto:

trait Sys {
  type S = this.type  // ?
  type Tx
  type Id <: Identifier[S#Tx]
}

trait Identifier[Tx] {
  def dispose()(implicit tx: Tx): Unit
}

trait Test[S <: Sys] {
  def id: S#Id
  def dispose()(implicit tx: S#Tx) {
    id.dispose()
  }
}

Que falla ...S#Tx yS#Id se separó de alguna manera

error: could not find implicit value for parameter tx: _9.Tx
               id.dispose()
                         ^

¿Algún truco o cambio que lo haga funcionar?

EDITAR : Para aclarar, principalmente espero arreglar el tipoS enSys para que funcione. Hay numerosos problemas en mi caso usando tipos dependientes de la ruta. Para dar solo un ejemplo que refleja las respuestas de pedrofuria y Owen:

trait Foo[S <: Sys] {
  val s: S
  def id: s.Id
  def dispose()(implicit tx: s.Tx) {
    id.dispose()
  }
}

trait Bar[S <: Sys] {
  val s: S
  def id: s.Id
  def foo: Foo[S]
  def dispose()(implicit tx: s.Tx) {
    foo.dispose()
    id.dispose()
  }
}

<console>:27: error: could not find implicit value for parameter tx: _106.s.Tx
               foo.dispose()
                          ^

Intenta hacer esodef foo: Foo[s.type] para darte una idea de que esto no lleva a ninguna parte.