Concise and exception-prone method for running method on component
Are there certain exceptions you can anticipate for onActorConnected?  Let's make an encompassing checked exception ActorUnconnectableException, though this would need to be be made more finegrained for particular connectivity issues:
class ActorUnconnectableException extends Exception {
    ActorUnconnectableException(Actor actor, MatchComponent component) {
        super(
            String.format(&quot;actor: %s cannot connect to component: %s&quot;, actor.getName(), component.getName())
        );
    }
}

And declare onActorConnect within MatchComponent like this:
void onActorConnect(Actor actor) throws ActorUnconnectableException {
    ...
}

The reason I advocate for a checked exception here is because it sounds like the it is hard to guarantee that an Actor is connectable without attempting to connect it. If we were able to verify that an Actor is connectable beforehand, an unchecked exception would be better suited here.
For something like a string that we're trying to parse as a number, let's say this parsable string is typed in our frontend. We can enforce through whatever frontend framework that this string contains only digits. That's why Integer::parseInt throws an unchecked exception, it expects that the validation is done before hand.
Another thing that can be improved is this:
if (actors.contains(actor))
     throw new IllegalArgumentException(format(&quot;Actor '%s' is already connected.&quot;, actor.getName()));

actors.add(actor);

Apart from adding braces for the if, we can utilize the fact that actors::add returns true if actor is not contained, otherwise false, like this:
boolean actorAdded = actors.add(actor);

if (!actorAdded) {
    throw new IllegalArgumentException(format(&quot;Actor '%s' is already connected.&quot;, actor.getName()));
}

This should remain an unchecked exception cause the calling code should be able to determine whether it already added an Actor equal to actor beforehand.
The rest of connectActor ends up looking like this:
var unconnectableComponents = new ArrayList&lt;MatchComponent&gt;();

for (MatchComponent component : components) {
    try {
        component.onActorConnect(actor);
    }
    catch (ActorUnconnectableException e) {
        unconnectableComponents.add(component);
    }
}

// Log `unconnectableComponents` or create new exception to report their collective failure.

This definitely ends up looking verbose, but the idea is that we want things outside of the calling code's control (like whether can actor is in fact connectable, which sounds like it can't be decided beforehand) to be checked at compile time.