Should abstract + default body be an error when two traits declare the same method?

[SeanTAllen]

When two traits declare the same method and both provide a default body, the compiler errors: "multiple possible bodies for method hello, local disambiguation required." Two abstract declarations work too — the implementing type must provide its own body, no ambiguity. But there's a third case. One trait declares the method abstract, the other provides a default body. The compiler silently adopts the default body.

// Two abstract — implementing type must provide a body. No ambiguity.
trait A1
  fun hello(env: Env)
trait A2
  fun hello(env: Env)
actor Main is (A1 & A2)  // must provide hello

// Two defaults — error: "multiple possible bodies"
trait B1
  fun hello(env: Env) => env.out.print("from B1")
trait B2
  fun hello(env: Env) => env.out.print("from B2")
actor Main is (B1 & B2)  // error

// One abstract, one default — currently compiles, silently picks the default
trait C1
  fun hello(env: Env)
trait C2
  fun hello(env: Env) => env.out.print("from C2")
actor Main is (C1 & C2)  // gets C2's body

The abstract declaration and the default body are competing declarations from different traits. A Serializable trait with an abstract serialize and a Printable trait with a default serialize are unrelated methods with the same name. The implementing type gets Printable's body with no error.

Pony has no mechanism for local disambiguation — no way for an implementing type to say "use this trait's body for this method."

This came up during #5825 / #5827, which fixed a crash when combining traits this way. The crash is gone, but the silent adoption of the default body is still there.

Should the mixed case produce the same error as the two-default case?