Multiple Auth Provider logins is working in prototype
Each individual user is represented by a Master Account (RateThisFest
Account or RTFAccount).  The master account "owns" or represents the use
of multiple Authentication Provider Accounts
Each service that the user may hold an account with (Google, Facebook,
Twitter, etc) is an Authentication Provider (Auth Provider).

The user is 'logged in' though the web interface by storing the user's
RTFAccount information in the browser's session state.  How session state
is tracked is beyond the scope of these comments but it provides a
reasonable amount of security.  Similarly, if the user wishes to logout,
the RTFAccount information is removed from the session state and the user
becomes indistinguishable from a user who has never logged in.

All RTFAccount and AuthProviderAccount records are saved in the GAE
datastore.

The relationship between RTFAccount (Master Account) and
AuthProviderAccount is managed by the login framework under the following
rules:

If a new user logs in to an Auth Provider, the system checks whether this
Auth Provider is registered under any RTFAccount (Master Account).  If the
system has never seen this Auth Provider Account before, it creates a new
RTFAccount, marks it as the owner of this AuthProviderAccount, and logs
the user in.
(Bob uses RateThisFest for the first time and logs in via Facebook.  RTF
has never seen Bob's facebook account before so it creates a new RTF
account (RTFAccount[Bob], marks it as the owner of
AuthProviderAccount[Facebook,Bob], and logs in Bob's browser session under
RTFAccount[Bob])

If a user is already logged in to their Master Account (RTFAccount) and
then logs into an Auth Provider Account which RTF has not seen, the new
Auth Provider Account is saved in the datastore and listed as being owned
by the user's Master Account (RTFAccount)
(Bob is already logged in under RTFAccount[Bob] when he wants to use a
function requiring Twitter access.  Bob authenticates with Twitter.  RTF
sees Bob authenticate with AuthProviderAccount[Twitter,Bob] while he is
already logged in to RTFAccount[Bob].  Since RTF has never seen
AuthProviderAccount[Twitter,Bob] before, AuthProviderAccount[Twitter,Bob]
is saved in the datastore along with the fact that it is owned by
RTFAccount[Bob].)

When no RTFAccount is logged in, the user can login to their RTF account
by logging into any AuthProviderAccount that is associated with their
RTFAccount.
(Bob goes to his friend's house and decides to use RTF.  Bob can get full
access to his RTF account by logging in through either Twitter or Facebook
but he does not need to login through both.)

RTF does not offer the user the option to login to an Auth Provider that
they have already logged into.  (When Bob is logged into his RTF account,
he never sees an option to authenticate with Facebook or Twitter because
those two Auth Providers are already associated with his account)

An attempt to associate an AuthProviderAccount with a second Master
Account (RTFAccount) will throw an exception that can be caught and
handled by the servlet.
(Bob goes to Alice's house, Alice is logged in to her account
RTFAccount[Alice], which owns AuthProviderAccount[Google, Alice] and
AuthProviderAccount[Twitter, Alice].  Bob starts using RTF on Alice's
computer, completely forgets what he is doing, and tries to post something
to Facebook.  RTF asks the user to authenticate RTFAccount[Alice] with
Facebook.  Bob types in his facebook username and password and RTF
receives AuthProviderAccount[Facebook, Bob] as the authentication result.
RTF sees that AuthProviderAccount[Facebook, Bob] is already listed as
owned by RTFAccount[Bob].  RTF refuses to allow the user to add
AuthProviderAccount[Facebook, Bob] to RTFAccount[Alice]