declare
    A : Integer;
    B : Float;

    procedure Foo (A : out Integer; B : out Float);
begin
   Foo (A, B);
   ...
end;

where Foo initializes A, B.

In general, I prefer to initialize variables in the declaration, and
declare them constant if possible. But I can't do that here.

One option in current Ada is to declare a record type;

declare
    type Foo_Return_Type is record
        A : Integer;
        B : Float;
    end record;

    function Foo return Foo_Return_Type is
    begin
        return
            (A => 1,    
             B => 2.0);
    end Foo;

    A_B : constant Foo_Return_Type := Foo;
begin
   ...
end;

But that seems like overkill, especially since the code in "..." must be
edited; all references to A must be replaced by A_B.A.

If we introduce the notion of "anonymous aggregates" (styled after
"anonymous arrays"), we could do this:

declare
    function Foo return
     (A : Integer;
      B : Float)
    is begin
        return
            (A => 1,    
             B => 2.0);
    end Foo;

    (A : constant integer,
     B : constant Float) := Foo;
begin
   ...
end;

I haven't thought much about how this would be implemented.

(in the declarations section, just after the initialisation of A_B)
A : constant Integer renames A_B.A;

1. anonymous record types, one of the things I liked to have very much as
well as an ability to use anonymous arrays and aggregates as components.

The syntax is obvious:

function Foo return
   record
      A : Integer;
      B : Float;
   end record;

2. Usage of aggregates (of any kind) on the left side of assignment and in
out parameters. One could consider Ada 2012 aliased parameters somehow
extended on record components and array elements.

Another possible mechanism could be argument type conversion as in Ada 83
when a tuple (A, B) explicitly converted to a record as out parameter. This
roughly corresponds to your idea.

declare
    function Foo return
       record
          A : Integer;
          B : Float;
        end record
    is begin
        return
            (A => 1,
             B => 2.0);
    end Foo;

(As a side-benefit, there'd be less griping about not repeating the name in
a record declaration. ;-)

I suspect that this was not done originally in Ada mainly because of
concerns about arbitrarily introducing additional identifiers in the middle
of other declarations. Not sure that's a real problem; there might be some
weird visibility issues that arose.

SubType Initializing_Info is Boolean; -- To be changed for later/complex items.
Function Testing( Init : Initializing_Info ) Return
        record
           A : Integer;
           B : Float;
         end record
     is begin
         return Result : Testing'Return'Type:=
             (A => 1,
              B => 2.0) do
             if Init then
                 A := 23;
             end if;
         end return;
     end Testing;