I'm gonna try to talk out the code, that is convert the statements into
English.

Some of the easy stuff is that:

Bar is a class paramterized on two things.
Baz is a class paramterized on one thing.
Foo is not paramterized.

There are two methods left and that is the hairy stuff.
Let's look at the one invoked first:

doFoo has an argument which is a Bar  and we know that Bar is
paramterized on two things.  doFoo's Bar argument is paramterized on a
subclass of Foo and a Baz which is itself paramterized on a subclass of
a subclass of Foo (right?).  That does not make sense to me, T  extends
Foo and Baz is paramterize on ? extends T.  Does that mean that we need
a subclass of a subclass?

Could we write doFoo like so:

public <T extends Foo> void doFoo(Bar<T, Baz<T>> bar) {

Compiler does not accept it.  Why not?

It accepts:
public <T extends Foo> void doFoo(Bar<? extends Foo, Baz<? extends
Foo>> bar) {

But I cannot substitute "? extends Foo" with T.  Should that be the
case?

The generics stuff clearly opens up possibilites that are hard to think
about.  It's like C++ stuff.  Fortunately in practice code (my code
anyway) never gets to this point.  Generics in practice seem to be
conveniences for reducing typing casts.

Thanks, but no, it shouldn't.  Your proposed change means something
different from the original code.  It does not in any case solve the
problem, for I find that the type bounds aren't the issue after all.
For example, this version also doesn't compile:

====

package test;

public class TestWildcards {

    public void foo(Bar<Baz<?>> bar) {
    }

    public <T> void doFoo(Bar<Baz<T>> bar) {
        foo(bar);  // <=== Incompatible types here (still)
    }
}

class Bar <X> {}

class Baz <Z> {}

====

This version clarifies the problem, I think, to the extent that I can
now articulate it clearly.  It is true that Baz<T> is a subtype of
Baz<?>, but that does not make Bar<Baz<T>> a subtype of Bar<Baz<?>>, the
wildcard notwithstanding.  This is in fact correct, as it is exactly
analogous to List<Object> vs. List<String>.  Adding additional type
parameters to Bar makes it harder to identify the real issue, but
doesn't fundamentally change it.