I would like to offer a different approach than the accepted answer based on event sourcing + cqrs.
Event sourcing is a different approach than nor relational design. You basically have only one table lets call it events. An event Is something that happened in the past tense. I.e AccountCreated MoneyDeposited. These events are classes that you serialize to text with your favorite serializer. The events have a defined ordering which means we can build something on top.
CQRS means command query resposibility segregation. It means we have two models. One for writing and one for reading. Lets focus on the write model. Every time you want to change your object you save an event to the stream. Lets say we save a MoneyDeposited event. We make an event handler inside our class. A ultra simple example could look like this(some infrastructure missing).
class BankAccount{
long Balance{get;set;}
void Deposit(long amount){SaveEvent(new MoneyDeposited(AccountId,amount); }
void Apply(MoneyDeposited m){balance += m.Amount; }
}
Since we now have split the apply method out we can read an entire stream from db which just calls Apply().
This means we can easily check the consistency rules. Lets say the WithDraw() method has insuffficent funds. It will throw before publishing the event. We can also easily use optimistic concurrency to check that two objects are being modified concurrently leading to inconsistencies since we read row n from db we increment row in memory to n+1 and thus a simple unique index will fail if some other thread wrote that row before us.
This is all simplified quite a bit, but your goal was to use a time machine and with the streams you just choose the row number you want to read and ignore anything newer.
I haven't event touched the read models yet but a long store short is that in some other storage you build a number of representations based on the events ready to eat.
Some keyworks to get you started on this. CQRS event sourcing. Try to find presentations from Gregg Young, Udi Dahan and Rinat Abdullin. Some useful frameworks: NEventStore(.NET) or Cirqus(.NET) even if it is quite young.