If the type parameter does not appear in the types of the method arguments, then the compiler cannot infer the type arguments by examining the types of the actual method arguments. If the type parameter appears in the method's return type, then the compiler takes a look at the context in which the return value is used. If the method call appears as the righthand side operand of an assignment, then the compiler tries to infer the method's type arguments from the static type of the lefthand side operand of the assignment

далее по тексту:
An invocation context other than an assignment is not considered for type inference. The result of the method call might be passed as an argument to another method, for instance. The compiler does not try to perform any special type inference in that case. Instead the compiler handles the method call as though it would appear in no context. No context means that the compiler performs the type inference algorithm as though the method result was assigned to a variable of type Object .

P_A>clean(list, newFilter());  
P_A>

public class Sample2 {
    public static void main(String[] args) {

        List<B> list = new ArrayList<B>();
        clean(list, newFilter(B.class)); 
    }

    private static <T extends A> Filter<T> newFilter(Class<T> clz) {
          return new MyFilter<T>();
      }

    private static <T extends A> void clean(Iterable<T> iterable, Filter<T> filter) {
        for (Iterator<T> iterator = iterable.iterator(); iterator.hasNext();) {
            T t = iterator.next();
            if (filter.accept(t))
                System.out.println(t);
            else
                System.out.println("Rej: " + t);
        }
    }
}

$ javac Sample2.java
$ java Sample2      
Rej: B@3e25a5
Rej: B@19821f

clean(list, newFilter());

clean(list, new MyFilter<B>());

import java.util.Iterator;
import java.util.List;
import java.util.ArrayList;

public class Sample {
    public static void main(String[] args) {

        List<B> list = new ArrayList<B>();

        clean(list, new MyFilter<B>());
                
        //error{
        // <T>clean(java.lang.Iterable<T>,Filter<T>) in Main cannot be applied to 
        //         (java.util.List<B>,    Filter<A>)
        clean(list, newFilter()); 
        //}
    }

    private static <T extends A> Filter<T> newFilter() {
          return new MyFilter<T>();
      }


    private static <T extends A> void clean(Iterable<T> iterable, Filter<T> filter) {
        for (Iterator<T> iterator = iterable.iterator(); iterator.hasNext();) {
            T t = iterator.next();
            if (filter.accept(t))
                System.out.println(t);
        }
    }
}

interface A {
    boolean isA();
}

class B implements A {
    public boolean isA() {
        return false;
    }
}

interface Filter<T> {
    boolean accept(T t);
}

class MyFilter<T extends A> implements Filter<T> {
    public boolean accept(T t) {
        return t.isA();
    }
}

public static void main(String[] args) {

    //почему это работает
    List<? extends A> list = new ArrayList<B>();

    //а это нет: error{
    //clean(java.lang.Iterable<T>,Filter<T>) in Main cannot be applied to 
    //(java.util.List<capture#995 of ? extends A>,MyFilter<B>)
    clean(list, new MyFilter<B>());
    }
}