Redesign of registration process.

1) Added a country selector and as-you-type number formatting.

2) Split out the registration progress into a separate "modal"
   activity that explains what is happening and gives deterministic
   progress.

3) Put the logic into a service, with the Activity serving as a view
   for the service, which should allow users to change focus without
   any adverse effects.

4) Redesigned the look to be hopefully less ugly.

5) Allow processing in background, with a notification on error/success
   if the registration activity is not in focus.
Be sure to finish activity, and don't mess with keepalives.
Fix for state management issues with registration flow.
Touch up the new registration process.

1) Change language introducing the registration process.

2) Refactoring based on SOA feedback + class-level comments.

3) Added confirmation dialog before launching verification.
Merge pull request #78 from WhisperSystems/registration

Redesign of registration process.
Update support library
Make registration activities singleTask
Adding speakerphone and mute buttons
Strip leading zeros from country code during registration.
Merge pull request #77 from WhisperSystems/spkr_mute_btns

Speakerphone and Mute Buttons
Merge pull request #87 from WhisperSystems/no_leading_zero

Strip leading zeros from country code during registration.
Updated language translations
Bump version to 0.9
Fixed wraparound bugs in SequenceCounter

SequenceCounter appeared to be breaking when the short id wrapped around. It appeared to use the xor operator where a 'raised to' was intended, and could become stuck in a bad state because 'lastPhysicalSequenceNumber' never ever decreased.

I tested with the following:

    java.util.Random r = new java.util.Random();
    SequenceCounter s = new SequenceCounter();
    long t = 0;
    for (long i = 0; i < (1L << 32); i++) {
        // perturb by an amount less than half of the wraparound range
        t += r.nextInt(1 << 16) - (1 << 15);
        // check if converter tracks the perturbation correctly
        if (s.convertNext((short)t) != t)
            throw new RuntimeException("desync");
    }

which ran without throwing any desync exceptions.
Clarified SequenceCounter

Rewrote my rewrite of SequenceCounter so that it was shorter, avoided constants and bit manipulation, and clearer.

Small justifying note: the cost to short in the expression (short)(nextShortId - prevShortId) is necessary in order to get the smallest possible delta. Java promotes shorts to ints before doing operations so, without the cast, going from short.MaxValue to short.MinValue would compute a delta of +1-(1<<16) instead of just +1.

I tested with this code:

    	java.util.Random r = new java.util.Random();
    	SequenceCounter s = new SequenceCounter();
    	long t = 0;
        for (long i = 0; i < (1L << 32); i++) {
        	short delta = (short)r.nextInt(1 << 16);
    		t += delta;
    		short shortenedT = (short)t;
    		long restoredT = s.convertNext(shortenedT);
    		if (restoredT != t) 
    			throw new RuntimeException("desync");
    	}

which basically check that, as long as the difference between each id fits in a short, no information is lost.
Fixed tab/space indentation