So even though the sub declaration has been seen before you get to the call to it, it hasn't yet been compiled?

No it hasn't. You seem to be confusing Foo with the anonymous sub

1. BEGIN { ... } is compiled.
   1. my $x = 12345; is compiled.
   2. *Foo = sub(){ $x }; is compiled.
2. BEGIN { ... } is executed.
   1. my $x = 12345; is executed.
   2. *Foo = sub(){ $x }; is executed. ⇐ &Foo is declared and defined here.
3. print Foo() is compiled. ⇐ &Foo is known to be constant.
4. [ Execution phase starts ]
5. print 12345 is executed.

vs

1. { ... } is compiled.
   1. my $x = 12345; is compiled.
   2. *Foo = sub(){ $x }; is compiled.
2. print Foo() is compiled. ⇐ &Foo is implicitly declared and called as a plain sub here.
3. [ Execution phase starts ]
4. { ... } is executed.
   1. my $x = 12345; is executed.
   2. *Foo = sub(){ $x }; is executed. ⇐ &Foo is defined here.
5. print &Foo() is executed.

In fact, the prototype is always completely ignored if the subroutine call is compiled before the prototype is added.

*Foo = sub($) { print "$_[0]\n" };
sub Bar($) { print "$_[0]\n" }

my @array = qw( a b c );
Foo(@array);  # a
Bar(@array);  # 3
[download]

Since it used to work like you (and me) suggest in 5.6, I suppose some aspects of "constant folding" and/or "reference counting" changed slightly in between.

Maybe due to another bugfix? Who knows...

Anyway, IMHO the docs should be updated to be clearer in this respect.

Cheers Rolf