Creating a generic list of dbset for enumeration

The way you'd normally do this is to use a List<Something> where Something is a common base-class or interface that all the types will support. At the moment, the closest you have is object, but you might be able to add some non-generic base-class / interface to your Table<TEntity>. The question, though, is : would it be useful? at best you could expose the Name; you can't usefully talk about a DbSet<T> without a <T>, except perhaps as the non-generic IEnumerable/IQueryable; so:

internal interface ITable
{
    string Name {get;}
    IQueryable Source {get;}
    IQueryable Destination {get;}
    Type Type {get;}
}

and use List<ITable> ?

Where Table<T> becomes:

internal class Table<TEntity> : ITable where TEntity : class
{
    internal string Name {get; set;}
    internal DbSet<TEntity> Source {get; set;}
    internal DbSet<TEntity> Destination {get; set;}

    string ITable.Name => Name;
    IQueryable ITable.Source => Source;
    IQueryable ITable.Destination => Destination;
    Type ITable.Type => typeof(T);

    internal Table(string name, DbSet<TEntity> source, DbSet<TEntity> destination)
    {
        Name = name;
        Source = source;
        Destination = destination;
    }
}

Since EF Core doesn't have a non-generic Set method, @DavidG's suggestion of making Execute generic looks like the way to go. You just have to "springboard" to it for each type with a little reflection.

var source = new SourceContext();
var destination = new DestinationContext();

var tables = new List<(string, Type)>
{
    ("Table A", typeof(TableA)),
    ("Table B", typeof(TableB))
};

var executeMethodInfo = GetType().GetMethod("Execute");
foreach (var (displayName, entityType) in tables)
{
    executeMethodInfo.MakeGenericMethod(entityType)
        .Invoke(this, new object[] { displayName, source, destination });
}

The generic Execute method would look like this:

public void Execute<T>(string displayName, SourceContext source, DestinationContext destination)
    where T : class
{
    Console.WriteLine($"Processing {displayName}");

    destination.RemoveRange(destination.Set<T>());
    destination.SaveChanges();

    destination.AddRange(source.Set<T>().AsNoTracking().ToList());
    destination.SaveChanges();
}