Why is a Holder never equal to a Named that extends it, even with the same count?

#!ek9
defines module qa.operators.different.types.never.same

  defines constant
    firstName <- "x"

  defines class

    Holder as open
      count as Integer: 1

      Holder()
        -> start as Integer
        this.count: start

      default operator

    Named extends Holder
      name as String: String()

      Named()
        ->
          start as Integer
          label as String
        super(start)
        this.name: label

      default operator

  defines function

    flag()
      -> answer as Boolean
      <- rtn as String: answer? <- $answer else "unset"

    shown()
      -> comparison as Integer
      <- rtn as String: comparison? <- $comparison else "unset"

  defines program

    DifferentTypesNeverTheSame()
      stdout <- Stdout()
      plain <- Holder(2)
      named <- Named(2, firstName)
      stdout.println(`Holder(2) == Named(2, x): ${flag(plain == named)}`)
      stdout.println(`Holder(2) <> Named(2, x): ${flag(plain <> named)}`)
      stdout.println(`Holder(2) <=> Named(2, x): ${shown(plain <=> named)}`)

      //The object decides: held is a Named, so Named's '==' runs.
      held as Holder: Named(2, firstName)
      stdout.println(`held == Named(2, x): ${flag(held == named)}`)
      stdout.println(`held == Named(2, y): ${flag(held == Named(2, "y"))}`)

      holders as List of Holder: [named]
      stdout.println(`contains Holder(2): ${flag(holders contains plain)}`)

      counts as Dict of (Holder, String): {plain: "plain"}
      newEntry as DictEntry of (Holder, String): DictEntry(held, "named")
      counts += newEntry
      stdout.println(`entries: ${length counts}`)