**Apache Airflow version**:  1.10.10


**Kubernetes version (if you are using kubernetes)**: 1.14.10

**Environment**:

- **Cloud provider or hardware configuration**: Any, GCP 
- **OS** (e.g. from /etc/os-release): Ubuntu 1.10.10
- **Kernel** (e.g. `uname -a`): Any
- **Install tools**: Any
- **Others**: NA

**What happened**:
DAGs with ExternalTaskMarker don't clean external task after second usage of clean on whole DAG


**What you expected to happen**:

All external task should be cleaned

**How to reproduce it**:
enable serialization `store_serialized_dags = True`

create example DAGs:

```
default_args = {'owner': 'airflow',
                'start_date': datetime(2018, 1, 1)}

def hello_world_py(*args):
    print('Hello World')
    print('This is DAG is dep}')

schedule = '@daily'
dag_id = 'dep_dag'
with DAG(dag_id=dag_id,
         schedule_interval=schedule,
         default_args=default_args) as dag:
    t1 = PythonOperator(task_id='hello_world',
                        python_callable=hello_world_py,)
    dep_1 = ExternalTaskSensor(task_id='child_task1',
                               external_dag_id='hello_world_2',
                               external_task_id='parent_task',
                               mode='reschedule')
    dep_1 >> t1

def create_dag(dag_id, schedule, dag_number, default_args):
    dag = DAG(dag_id, schedule_interval=schedule,
              default_args=default_args)
    with dag:
        t1 = PythonOperator(task_id='hello_world',
                            python_callable=hello_world_py,
                            dag_number=dag_number)
        parent_task = SerializableExternalTaskMarker(task_id='parent_task',
                                         external_dag_id='dep_dag',
                                         external_task_id='child_task1')
        t1 >> parent_task
    return dag

for n in range(1, 4):
    dag_id = 'hello_world_{}'.format(str(n))
    default_args = {'owner': 'airflow',
                    'start_date': datetime(2018, 1, 1)}
    schedule = '@daily'
    dag_number = n
    globals()[dag_id] = create_dag(dag_id, schedule, dag_number, default_args)
```

1. Run both DAGs
2. Wait until first few dagruns where completed
3. Clean first dugrun in DAG with marker
4. Check external dug was cleaned on this date
5. Mark success this date in each DAGs or wait until complete
6. Clean DAG with marker second time on same date
7. ExternalTaskMarker don't work

**Anything else we need to know**:
I think ExternalTaskMarker don't work because of serialization, after serialization each task instance get operator field equal 'SerializedBaseOperator' and markers logic dot' work [here](https://github.com/apache/airflow/blob/master/airflow/models/dag.py#L1072) 

To test ExternalTaskMarker with serialization you can use:

<details>

```
from airflow.sensors.external_task_sensor import ExternalTaskMarker
class FakeName(type):

    def __new__(metacls, name, bases, namespace, **kw):
         name = namespace.get("__name__", name)
         return super().__new__(metacls, name, bases, namespace, **kw)
class SerializableExternalTaskMarker(ExternalTaskMarker, metaclass=FakeName):

    # The _serialized_fields are lazily loaded when get_serialized_fields() method is called
    __serialized_fields = None  # type: Optional[FrozenSet[str]]
    __name__ = "ExternalTaskMarker"

    @classmethod
    def get_serialized_fields(cls):
        """Serialized BigQueryOperator contain exactly these fields."""
        if not cls.__serialized_fields:
            cls.__serialized_fields = frozenset(
                ExternalTaskMarker.get_serialized_fields() | {
                    "recursion_depth", "external_dag_id", "external_taskid", "execution_date"
                }
            )
        return cls.__serialized_fields
```

</details>

@kaxil 
airflow/models/taskinstance.py
self,
            task_ids: Optional[Union[str, Iterable[str]]] = None,
            dag_id: Optional[str] = None,
            key: str = XCOM_RETURN_KEY,
            include_prior_dates: bool = False) -> Any:
        """
        Pull XComs that optionally meet certain criteria.
        The default value for `key` limits the search to XComs
        that were returned by other tasks (as opposed to those that were pushed
        manually). To remove this filter, pass key=None (or any desired value).
        If a single task_id string is provided, the result is the value of the
        most recent matching XCom from that task_id. If multiple task_ids are
        provided, a tuple of matching values is returned. None is returned
        whenever no matches are found.
        :param key: A key for the XCom. If provided, only XComs with matching
            keys will be returned. The default key is 'return_value', also
            available as a constant XCOM_RETURN_KEY. This key is automatically
            given to XComs returned by tasks (as opposed to being pushed
            manually). To remove the filter, pass key=None.
        :type key: str
        :param task_ids: Only XComs from tasks with matching ids will be
            pulled. Can pass None to remove the filter.
        :type task_ids: str or iterable of strings (representing task_ids)
        :param dag_id: If provided, only pulls XComs from this DAG.
            If None (default), the DAG of the calling task is used.
        :type dag_id: str
        :param include_prior_dates: If False, only XComs from the current
            execution_date are returned. If True, XComs from previous dates
            are returned as well.