aa is a PVector, it hasn't the Thread's methods, so you cannot call start() on it.
But internally, it can access the parent's methods, like getId().
It is Inner calling Outer methods, while in the non-working line, it is the applet trying to call a non-existing method on Inner.
In other words, Inner access Outer's methods, but doesn't expose them to the outer world.

In other words, Inner accesses Outer's methods, but doesn't expose them to the outer world.

Well, it seems so unfortunately. 
I can change declaration -> final Outer.Inner aa = a.new Inner();
to this equivalent one     -> final PVector aa = a.new Inner();

Outer.Inner behaves as a PVector. But not as a Thread nor as a PApplet! 

P.S.: A shortcut instantiation: 
final Outer.Inner a = new Outer().new Inner();   or   final PVector a = new Outer().new Inner();

Indeed.
And, yes, you can declare an object's type as one of its ancestor (class or interface).
We do that often for array lists:
List<String> l = new ArrayList<String>();
It restricts the methods to those of the parent (often enough, and we still can cast the object to access the specialized methods of the child) but it allows to change the implementation without changing the API, or to make a collection of heterogeneous objects with a common trait (list of shapes, drawn as circles, triangles, etc.).

(You probably know all this, GoToLoop, I write for other people as well...)

" it seems so unfortunately"
Indeed, that's a limitation of Java: it is recommended to use composition instead of inheritance (instead of "extends Foo", put an instance of Foo inside the object) but if we want to expose some behavior of Foo to the outer world (make the object to act like a Foo), we have to write lot of boilerplate code like:
int getBaz() { return foo.getBaz(); }
which becomes quickly tedious...

(You probably know all this, GoToLoop, I write for other people as well...)

Yup, I do!    Actually I'm the only 1 posting codes w/ ArrayList by declaring its parent interface:
List<String> myList = new ArrayList();

A pity Processing 2+ needs import java. util. List; for that to work. 

And finally, just found out the hack to expose all multi-inherited methods & fields to outside classes! 
Behold my super multi-inherited inner class: 

      // MultiInheritence.pde:

---

/** 
 * Multi-Inheritance (v2.01)
 * by GoToLoop (2013/Jul)
 * by GoToLoop
 * 
 * http://forum.processing.org/topic
 * /hacking-multi-inheritance-by-inner-classes
 */

void setup() {
  noLoop();

  final Outer.Inner a = new Outer().new Inner();
  //final Outer.Inner a = new Outer(this).new Inner();

  println(a.o);  // access PVector part

  a.start();     // access Thread  part
  delay(100);

  println(a.o);  // modified PVector part

  a.o.p.line(10, 10, 90, 90);  // access PApplet part
  a.o.p.line(90, 10, 10, a.o.p.height - 10);

  //exit();
}

class Outer extends PVector {
  final MultiInheritance p = MultiInheritance.this;
  //final PApplet p;

  /*
  Outer(PApplet pa) {
   p = pa;
   }
   */

  class Inner extends Thread {
    final Outer o = Outer.this;  // Outer's reference

    {
      x = getId();        // Thread's  method
      y = getPriority();  // Thread's  method
      z = 4*atan(1);      // PApplet's method
    }

    void run() {
      sub(20, 10, -5);    // PVector's method
      println("Running!");
    }
  }
}