Adds support for nested transactions to postgres via savepoints
Interesting PR.  I'm actually looking at refactoring the transaction code to use a stack for #265 , though I did not plan on implementing nested txns using savepoints.

I'm not sure I like overloading `begin` to now mean "create a savepoint".  Same for `rollback`.  These should always mean either begin a transaction or roll it back.
 Ok, now I only will create a savepoint in `begin()` for the nested transactions.

In Postgres there is no notion of nested transactions via `BEGIN`. A 2nd call to `BEGIN` will just be ignored. Their recommendation is to create a save point if the intention is to support nesting. That is what the 2nd commit now does. Only nested rollback/commit now release/rollback the savepoints.

This change now supports #265 I believe, on Postgres at least. I think that MySQL would be the same basically, at least with InnoDB.

I like this approach vs having to force the user to think about savepoints, and how nesting is supported across `Database` implementations. This just says that peewee will support nesting, and the details are up to the `Database` implementation.
 > I like this approach vs having to force the user to think about savepoints.

That's a valid point.
 It looks like MySQL and Sqlite support savepoints as well.  Have you looking into how this PR works with those databases?
 Rather than expose savepoints as nested transactions, I've created a new method / context manager.

``` python

with db.savepoint():
    do stuff
```
 I like adding explicit savepoint support, but are you saying you don't want to support nested transactions in postgres like this?
 Well, I added support for nesting calls to `transaction`, but the transactions are not nested per-se.  I will add support for savepoints as a separate API using an approach similar to the transaction context mgr.
 Added savepoint support:

``` python
with db.transaction():
    # etc
    with db.savepoint():
        # etc
        with db.savepoint():
            # etc
```
 Cool, I'll check it out.

Postgres supports nested transactions by way of savepoints.

http://www.postgresql.org/docs/9.3/static/sql-savepoint.html

An example usage is

``` sql
BEGIN;
    INSERT INTO table1 VALUES (1);
    SAVEPOINT my_savepoint;
    INSERT INTO table1 VALUES (2);
    ROLLBACK TO SAVEPOINT my_savepoint;
    INSERT INTO table1 VALUES (3);
COMMIT;
```

This patch adds savepoint support to the peewee PostgresqlDatabase. As is, PostgresqlDatabase doesn't implement begin, or support nested transactions. 

With this change nested transactions will only setup/rollback/release savepoints, the outermost transaction will do the commit/rollback.

begin: now creates a savepoint, and increments the nesting depth.
commit: releases the savepoint, and calls commit if not still nested.
rollback: rolls back to the savepoint, and calls rollback if not still nested.
