InvalidMemoryOperationError when calling functions from destructors

[Volfram]

I've run into a problem which I'd like to hope is a bug, but 
let's see if we can figure out if I'm doing something stupid 
first, eh?

When a destructor calls a function from another module, I get an 
InvalidMemoryOperationError.  When a destructor calls a function 
from another class in the same module, and that function calls 
the function I was trying to call initially, everything seems to 
go fine.  When a destructor calls a function in the same class, 
which calls a function in a different module, I get the 
InvalidMemoryOperationError again.

This may have to do with garbage collector subtleties I'm not 
familiar with.

Example:

File alpha.d
module alpha;

import beta;

class AlphaClass
{
     BetaClass bc;
     Alpha2Class a2c;

     void cleanup()
     {
         bc.cleanup();//if this is called from the destructor, 
expect an error.
     }

     public:
     this()
     {
         bc = new BetaClass();
         a2c = new Alpha2Class(bc);
     }
     ~this
     {
         bc.cleanup();//this will cause an error.
         a2c.cleanup();//this works fine
         cleanup();//this will cause an error.
     }
}

class Alpha2Class
{
     BetaClass bc;

     void cleanup()
     {
         bc.cleanup();
     }

     public:
     this(BetaClass initbc)
     {
         bc = initbc;
     }
}

File beta.d

module beta;

class BetaClass
{
     public:
     this()
     {
         //do something
     }
     void cleanup()
     {
         //clean up after the bosses
     }
}

Further info can be provided if necessary.