As a devil advocate, I can say about heuristics, that each idea should be extended to its maximum.
Ie. if the compiler has the ability to generate bridge method and if this generation can be defined in a consistent and univocal way, then the compiler should generate one. Otherwise, a programmer will need to learn, that ‘extending of idea stops here’, since the usual maximum extension heuristics is not works.
With overriding of the concrete methods the situation no longer univocal (compiler must know - what to deduce), so it’s the same as two unrelated traits with the same method definition. It’s obvious that compiler should stop (if we have no ‘abstract override’ in one of definitions)).
From another side, I understand the opposite point
Also interesting, that my filling about including delegation, depends on the possibility to implement this use-case in another way. Ie. if I expect, that in some hypothetical bright future, metaprogramming systems allow implementing something like
Delegated[T](t:T) extends T, then demand to the automatic delegation of exported methods looks low.
Maybe it’s a sign, that for delegation better raise the other language/ library change, which will allow generation of something like DynamicProxy.