[SWUtil] PropertyListItem: Clarify use of init overloads that take array and dictionary

The original comment that these overloads can be removed was incorrect
because the existential of `PropertyListItemConvertible` doesn't self
conform. The overloads are still needed to support collections with
heterogeneous values but nothing else and so they should be disfavored.

Turns out that some of the expressions that used to take advantage
of these overloads only work due to the solver producing a valid
solution from the "diagnostic" mode.

For example:

```
public var propertyListItem: PropertyListItem {
    return .init(entries
        .sorted { $0.identifier < $1.identifier }
        .map {
            [
                "bundle-id": .plString($0.identifier),
                "tags": PropertyListItem($0.tags.sorted()),
                "bundle-path": .plString($0.path.str),
            ]
        })
}
```

This expression should have been ambiguous because it can match
both `.init(any ...)` and `.init([any ...])` overloads due to an
existential conversion that is bi-directional for the closure.

For `.init(any ...)`, result of the closure is going to be erased
to existential inside of the body of the `.map` closure and for
`.init([any ...])`, this erasure is going to happen outside but
both are equally valid.

Author: xedin

Sources/SWBUtil/PropertyList.swift

@@ -362,16 +362,24 @@ extension Dictionary: PropertyListItemConvertible where Key == String, Value: Pr
 }
 
 public extension PropertyListItem {
-    init(_ x: any PropertyListItemConvertible) {
+    init<T>(_ x: T) where T: PropertyListItemConvertible {
         self = x.propertyListItem
     }
 
-    // Will remove this with rdar://problem/44204273
+    /// This overload is intended only to support arrays with heterogeneous values.
+    /// For example: ["", 42] can be represented as [any PropertyListItemConvertible]
+    /// but `any PropertyListItemConvertible` doesn't actually conform to
+    /// `PropertyListItemConvertible` hence we cannot use the overload above.
+    @_disfavoredOverload
     init(_ x: [any PropertyListItemConvertible]) {
         self = .plArray(x.map{$0.propertyListItem})
     }
 
-    // Will remove this with rdar://problem/44204273
+    /// This overload is intended only to support dictionaries with heterogeneous values.
+    /// For example: ["q": "", "a": 42] can be represented as [String: any PropertyListItemConvertible]
+    /// but `any PropertyListItemConvertible` doesn't actually conform to
+    /// `PropertyListItemConvertible`.
+    @_disfavoredOverload
     init(_ x: [String: any PropertyListItemConvertible]) {
         self = .plDict(x.mapValues { $0.propertyListItem })
     }