Issue Description:

Issue a compiler warning when assigning an object to a weak references that will likely be destroyed before the weak reference is used.

The simple but common case should be easy to diagnose:

 let delegate = Delegate()
 container.delegate = delegate
 // delegate is destroyed here at -O
 container.callDelegate()

Weak reference are often used to capture closure arguments, so that needs to be handled as well.

This pattern can generally be recogized as:

• a locally allocated object 'alloc_ref'

• assignment to a weak property or box (for a closure) 'store_weak'

• use of the property's parent object

• no subsequent use of the local object

However, this pattern won't catch uses involving asynchronous execution:

We also should try to diagnose this pattern...

import Dispatch
class SomeDispatcher {
  func runBackground(completionHandler: ()->()) { completionHandler() }
}
func foo() {
  let semaphore = DispatchSemaphore(value: 0)
  let dispatcher = SomeDispatcher()
  dispatcher.runBackground(completionHandler: { [weak dispatcher] in
      // This dispatcher check may be hidden within "runBackground".
      // The compiler won't necessarily see it.
      if let dispatcher = dispatcher {
          _ = dispatcher
          semaphore.signal()
      }
  })
  // 'dispatcher' will be destroyed here, before checking the semaphore unless
  // its lifetime is extended.
  semaphore.wait()
}

Here, 'dispatcher' is used (as self) in the same call that captures the weak reference. So the "no subsequent use" rule above does not apply here. The compiler would need to know that 'runBackground' is asynchronous.

Should we simply warn about any weak reference to a local variable passed to an asynchronous routine?