È sempre necessario usare weak o unowned nella lista…

No, non sempre.

Weak e unowned vengono utilizzati per prevenire cicli di riferimenti forti (retention cycles) nelle closure, quando la closure mantiene un riferimento forte a un oggetto, e l'oggetto a sua volta mantiene un riferimento forte alla closure.

È necessario usare weak o unowned quando la closure cattura un riferimento forte a self o ad un altro tipo referenziale, e c'è la probabilità di un ciclo di riferimenti forti.

Situazioni in cui non è necessario usare weak/unowned:

La closure cattura tipi di valore (strutture, enumerazioni, tuple). Questi vengono copiati al momento della cattura, e non si verificano cicli di riferimenti forti.
La closure cattura un tipo referenziale, ma non esiste un riferimento forte bidirezionale. Ad esempio, se la closure viene creata localmente all'interno di un metodo e non viene salvata in un oggetto a cui fa riferimento.
La closure ha una vita breve e viene eseguita prima che l'oggetto a cui fa riferimento venga deallocato. Ad esempio, una closure passata come Completion Handler che viene eseguita immediatamente.

Scelta tra weak e unowned:

weak: usato quando l'oggetto catturato può diventare nil in qualsiasi momento prima dell'esecuzione della closure. La referenza è opzionale (ObjectType?). È necessario verificare nil prima di usarla.
unowned: usato quando si sa che l'oggetto catturato esisterà sempre al momento dell'esecuzione della closure. La referenza non è opzionale (ObjectType). Non richiede verifica di nil. L'uso di unowned su un oggetto diventato nil causerà un crash (errore in runtime).

// Esempio in cui non sono necessari `weak`/`unowned` (cattura di struct)
struct MyStruct {
    var value: Int
}

let myStruct = MyStruct(value: 10)
let closure = {
    print(myStruct.value) // Cattura una copia di myStruct
}
closure()

// Esempio in cui non sono necessari `weak`/`unowned` (closure locale)
class MyClass {
    func doSomething() {
        let localValue = 5
        let localClosure = {
            print(self.description) // Cattura self, ma la closure non viene salvata in MyClass
        }
        localClosure()
    }

    var description: String {
        return "Instance of MyClass"
    }
}

let myObject = MyClass()
myObject.doSomething()

// Esempio in cui è necessario `weak` (potenzialmente nil)
class AsyncOperation {
    var completionHandler: (() -> Void)?

    func performOperation() {
        // Simulazione di lavoro asincrono
        DispatchQueue.global().async {
            print("Operation completed")
            self.completionHandler?() // chaining opzionale
        }
    }

    deinit {
        print("AsyncOperation deinitialized")
    }
}

class ViewController {
    var op: AsyncOperation?

    func setupOperation() {
        op = AsyncOperation()
        op?.completionHandler = { [weak self] in // weak self
            guard let self = self else { return }
            print("Completion handler in ViewController: \(self)")
        }
    }

    deinit {
        print("ViewController deinitialized")
    }
}

// Esempio in cui è necessario `unowned` (garantito esistente)
class Button {
    var action: (() -> Void)?

    func tap() {
        action?()
    }

    deinit {
        print("Button deinitialized")
    }
}

class ViewControllerWithButton {
    var button: Button

    init() {
        button = Button()
        button.action = { [unowned self] in // unowned self
            print("Button tapped in ViewControllerWithButton: \(self)")
        }
    }

    deinit {
        print("ViewControllerWithButton deinitialized")
    }
}

È sempre necessario usare weak o unowned nella lista di cattura?