Issue Description:

Dispatching a generic at run-time can cause problems when calling one generic to another. Specifically, the second generic function called from the first generic function loses its type information even though technically its available at compile time. This makes many techniques used in languages like C++ won't work in Swift.

For example:

protocol DispatchType {}
class DispatchType1: DispatchType {}
class DispatchType2: DispatchType {}

func doBar<D:DispatchType>(value:D) {
    print("general function called")
}

func doBar(value:DispatchType1) {
    print("DispatchType1 called")
}

func doBar(value:DispatchType2) {
    print("DispatchType2 called")
}

func test<D:DispatchType>(value:D) {
    doBar(value: value)
}

let d1 = DispatchType1()
let d2 = DispatchType2()

test(value: d1)     // "general function called", but expected "DispatchType1 called"
test(value: d2)     // "general function called", but expected "DispatchType2 called"

For the cases where this behavior is desired, a `@compile_time` attribute could be introduced to create the separate `test` functions so the desired behavior occurs. This would minimize the amount of code affected.

While using a protocol to get this behavior is possible, it can force large monolithic classes to occur (e.g. on stackoverflow). This modification would allow Swift to better support both an object orient and functional paradigm under these conditions.