embedded: change the function representation of directly called witness methods

This is needed in Embedded Swift because the `witness_method` convention requires passing the witness table to the callee.
However, the witness table is not necessarily available.
A witness table is only generated if an existential value of a protocol is created.

This is a rare situation because only witness thunks have `witness_method` convention and those thunks are created as "transparent" functions, which means they are always inlined (after de-virtualization of a witness method call).
However, inlining - even of transparent functions - can fail for some reasons.

This change adds a new EmbeddedWitnessCallSpecialization pass:
If a function with `witness_method` convention is directly called, the function is specialized by changing the convention to `method` and the call is replaced by a call to the specialized function:

```
  %1 = function_ref @callee : $@convention(witness_method: P) (@guaranteed C) -> ()
  %2 = apply %1(%0) : $@convention(witness_method: P) (@guaranteed C) -> ()
...
sil [ossa] @callee : $@convention(witness_method: P) (@guaranteed C) -> () {
  ...
}
```
->
```
  %1 = function_ref @$e6calleeTfr9 : $@convention(method) (@guaranteed C) -> ()
  %2 = apply %1(%0) : $@convention(method) (@guaranteed C) -> ()
...
// specialized callee
sil shared [ossa] @$e6calleeTfr9 : $@convention(method) (@guaranteed C) -> () {
  ...
}
```

Fixes a compiler crash
rdar://165184147

test/embedded/accessors.swift

@@ -8,6 +8,9 @@
 // REQUIRES: optimized_stdlib
 // REQUIRES: swift_feature_Embedded
 
+// For some reason integer hashing results in an undefined symbol "arc4random_buf" linker error on linux
+// REQUIRES: OS=macosx
+
 public class C {
   public var x: Int {
     _read {
@@ -21,6 +24,25 @@ public class C {
   var y: Int = 27
 }
 
+public protocol P {
+  var d: [Int : WrappedBool] { get set }
+}
+
+extension P {
+  mutating func set(key: Int) {
+    d[key]?.b = true
+  }
+}
+
+public struct WrappedBool {
+  public var b: Bool = true
+}
+
+public class S: P {
+  public var d: [Int : WrappedBool] = [:]
+  public func foo() {}
+}
+
 @main
 struct Main {
   static func main() {
@@ -33,5 +55,11 @@ struct Main {
 
     print("2") // CHECK: 2
     print("")
+
+    var handler = S()
+    handler.d[27] = WrappedBool(b: false)
+    handler.set(key: 27)
+    // CHECK: true
+    print(handler.d[27]!.b ? "true" : "false") 
   }
 }