Added support for the switch operation.
Reverted changes to junit and mockito imports in the Observable class.
Removed synchronized block as per RxJava guidelines (6.7).
fix concurrency bug in ScheduledObserver

- found a concurrency bug while working on https://github.com/Netflix/Hystrix/issues/123
- the following code would lock up occasionally due to onCompleted not being delivered:

```java
public class RunTest {
    public static void main(String[] args) {
        System.out.println("Starting test...");

        final ArrayList<String> strings = new ArrayList<String>(200000);

        int num = 10000;
        while (true) {
            long start = System.currentTimeMillis();
            final AtomicInteger count = new AtomicInteger();
            for (int i = 0; i < num; i++) {
                new TestService1(2, 5).toObservable().forEach(new Action1<Integer>() {

                    @Override
                    public void call(Integer v) {
                        count.addAndGet(v);
                    }
                });

                new TestService2("hello").toObservable().forEach(new Action1<String>() {

                    @Override
                    public void call(String v) {
                        strings.add(v);
                    }

                });
            }
            long time = (System.currentTimeMillis() - start);
            long executions = num * 2;
            System.out.println("Time: " + time + "ms for " + executions + " executions (" + (time * 1000) / executions + " microseconds)");
            System.out.println("   Count: " + count);
            System.out.println("   Strings: " + strings.size());
            strings.clear();
        }
    }
}
```

- Also made OperationObserveOn not use ScheduledObserver if the `ImmediateScheduler` is chosen to allow an optimization. I believe this optimization is safe because ScheduledObserver does not require knowledge of a Scheduler (such as for now()) and all we do is emit data to the Observer on a scheduler and if we know it's Immediate we can go direct and skip the enqueuing step. This allows shaving off a noticable number of microseconds per execution in the loop above.
Merge pull request #268 from benjchristensen/observeOn-fixes

Fix concurrency bug in ScheduledObserver
Gradle Release Plugin - new version commit:  'rxjava-0.8.4'.
Fix concurrency bug in ScheduledObserver

This is a followup to https://github.com/Netflix/RxJava/commit/1fa6ae3be23200c787cc1c25c0bb8cac99ae0d17 that fixed one issue (concurrency) and created another (broke Rx contract by allowing concurrent execution of onNext).

I have reverted back to the previous implementatio and then attempted to fix the concurrency issue again.

I think it ended up being a simple fix … just re-ordering the `enqueue` method to remove the race-condition between the logic protected by the AtomicInteger and adding to the queue.

It's not an atomic operation (adding then processing) so we need to just add to the queue and treat it as an async data structure and keep the AtomicInteger portion to only protecting the "process or not process" logic.

```java
        // this must happen before 'counter' is used to provide synchronization between threads
        queue.offer(notification);
```

This may still have issues but it's now working in all of my concurrency tests (the ones that broken with the original and then my modified version). The tests are not easy to build unit tests out of as they require running for many seconds and non-deterministically causing a race condition so I have not yet spend the time to try and figure out a deterministic unit test hence them not being committed.
Merge pull request #269 from benjchristensen/observeOn

Fix concurrency bug in ScheduledObserver
Gradle Release Plugin - new version commit:  'rxjava-0.8.5'.
Moving "implementation detail" classes out of public API
Move blocking operators to BlockingObservable

- see https://github.com/Netflix/RxJava/issues/270 for background
Deprecating 'toObservable' duplications of 'from' methods
Migrating from 'toObservable' to 'from' and using toBlockingObservable() where needed
Rewrite concat operation to not block on subscribe

The concat operator previously blocked on calling subscribe until all the
sequences had finished. In quite some cases this results in unwanted (and
unexpected) behaviour, such as when prefixing an infinite Observable
with a fixed one, for example when using startWith (which calls concat):
someInputStream.startWith(123).subscribe(x -> print(x));
This statement will block indefinitely if the input stream is infinite. Also
on finite sequences it seems silly to have to wait for them to finish.

In this new approach the incoming observables are put into a queue, instead
of waiting for the whole sequence to finish. When the first observable
completes, the next one is taken from the queue and subscribed to, and so
on. The queue can be extended while processing the observables, and
onCompleted is only called when both the source of observables has completed
and all observables in the queue have been read.
Make unit test more deterministic
README on internal nature of rx.operators package
Switch operator should now propagate onError in subsequences.
Replaced tabs with spaces.
Add new unit test to cover infinite observable being the first sequence.
Revert "Add new unit test to cover infinite observable being the first sequence."

This reverts commit 658d824b9f632f79a2b29979a6dfbb1a0a925783.