### Apache Airflow version

2.4.3, 2.5.0

### What happened

when use output from task decorator as parameter (external_task_ids) in ExternalTaskSensor, it show up this log:

```
Broken DAG: [+++++/airflow/dags/TEST_NEW_PIPELINE.py] Traceback (most recent call last):
  File "+++++/env3.10.5/lib/python3.10/site-packages/airflow/models/baseoperator.py", line 408, in apply_defaults
    result = func(self, **kwargs, default_args=default_args)
  File "+++++/env3.10.5/lib/python3.10/site-packages/airflow/sensors/external_task.py", line 164, in __init__
    if external_task_ids and len(external_task_ids) > len(set(external_task_ids)):
TypeError: object of type 'PlainXComArg' has no len()
```

note: +++++ is just a mask for irrelevant information.

### What you think should happen instead

this document https://airflow.apache.org/docs/apache-airflow/stable/tutorial/taskflow.html
show that we can use it without any warning, note about it.

found relative problem in [https://github.com/apache/airflow/issues/27328](url)
should move all the check in __\_\_init\_\___ into __poke__ method.

### How to reproduce

```
from airflow.decorators import dag, task
from airflow.operators.python import get_current_context

from airflow.sensors.external_task import ExternalTaskSensor
from datetime import datetime

configure = {"dag_id": "test_new_skeleton",
                    "schedule": None,
                    "start_date": datetime(2022,1,1),
}

@task
def preprocess_dependency() -> list:
    return ["random-task-name"]

@dag(**configure)
def pipeline(): 
    t_preprocess = preprocess_dependency()
    task_dependency = ExternalTaskSensor(task_id=f"Check_Dependency",
                                         external_dag_id='random-dag-name-that-exist',
                                         external_task_ids=t_preprocess ,
                                         poke_interval=60,
                                         mode="reschedule",
                                         timeout=172800,
                                         allowed_states=['success'],
                                         failed_states=['failed', 'skipped'],
                                         check_existence=True,)


dag = pipeline()
```


### Operating System

REHL 7

### Versions of Apache Airflow Providers

_No response_

### Deployment

Virtualenv installation

### Deployment details

_No response_

### Anything else

_No response_

### Are you willing to submit PR?

- [ ] Yes I am willing to submit a PR!

### Code of Conduct

- [X] I agree to follow this project's [Code of Conduct](https://github.com/apache/airflow/blob/main/CODE_OF_CONDUCT.md)

"""
    Waits for a different DAG, task group, or task to complete for a specific logical date.
    If both `external_task_group_id` and `external_task_id` are ``None`` (default), the sensor
    waits for the DAG.
    Values for `external_task_group_id` and `external_task_id` can't be set at the same time.
    By default, the ExternalTaskSensor will wait for the external task to
    succeed, at which point it will also succeed. However, by default it will
    *not* fail if the external task fails, but will continue to check the status
    until the sensor times out (thus giving you time to retry the external task
    without also having to clear the sensor).
    It is possible to alter the default behavior by setting states which
    cause the sensor to fail, e.g. by setting ``allowed_states=[State.FAILED]``
    and ``failed_states=[State.SUCCESS]`` you will flip the behaviour to get a
    sensor which goes green when the external task *fails* and immediately goes
    red if the external task *succeeds*!
    Note that ``soft_fail`` is respected when examining the failed_states. Thus
    if the external task enters a failed state and ``soft_fail == True`` the
    sensor will _skip_ rather than fail. As a result, setting ``soft_fail=True``
    and ``failed_states=[State.SKIPPED]`` will result in the sensor skipping if
    the external task skips.
    :param external_dag_id: The dag_id that contains the task you want to
        wait for
    :param external_task_id: The task_id that contains the task you want to
        wait for.
    :param external_task_ids: The list of task_ids that you want to wait for.
        If ``None`` (default value) the sensor waits for the DAG. Either
        external_task_id or external_task_ids can be passed to
        ExternalTaskSensor, but not both.
    :param allowed_states: Iterable of allowed states, default is ``['success']``
    :param failed_states: Iterable of failed or dis-allowed states, default is ``None``