PropertyWrapper: AllowDecodingFailure will catch decoding errors and return `nil` rather than failing the operation

_example.swift

struct Dingus: Codable {
    @AllowDecodingFailure var foo: String?
}

do {
    let model = try JSONDecoder().decode(Dingus.self, from: Data("{\"foo\": 123}".utf8))
    model.foo // nil
}
do {
    let model = try JSONDecoder().decode(Dingus.self, from: Data("{\"foo\": \"hello\"}".utf8))
    model.foo // hello
}
do {
    let model = try JSONDecoder().decode(Dingus.self, from: Data("{}".utf8)) // throws
    model.foo
}

AllowDecodingFailure.swift

@propertyWrapper
public struct AllowDecodingFailure<T: Codable>: Codable {
    public var wrappedValue: T?
    public var error: Error?
    public var projectedValue: AllowDecodingFailure<T> { self }

    public init(wrappedValue: T?) {
        self.wrappedValue = wrappedValue
        self.error = nil
    }

    public init(from decoder: Decoder) throws {
        do {
            self.wrappedValue = try T(from: decoder)
        } catch let error {
            self.error = error
        }
    }
    public func encode(to encoder: Encoder) throws {
        try wrappedValue.encode(to: encoder)
    }
}

extension KeyedDecodingContainer {
    public func decode<T>(_ type: AllowDecodingFailure<T>.Type, forKey key: KeyedDecodingContainer.Key) throws -> AllowDecodingFailure<T> {
        return AllowDecodingFailure(wrappedValue: try? decode(T.self, forKey: key))
    }
}