After dealing with some challenges and getting a good night's rest, I finally discovered the solution:

const { richTextFromMarkdown } = require('@contentful/rich-text-from-markdown')
const { createClient } = require('contentful-management')
        
module.exports = function(migration) 
{
    const managementClient = createClient({ accessToken: context.accessToken })
    const space            = await managementClient.getSpace(context.spaceId)
    const environment      = await space.getEnvironment(config.activeEnvironmentId)

     /**
     * Creates a hash for a given string
     * @param string
     */
    function createHash(string)
    {
        let hash = 0,
            i,
            chr

        if (string.length === 0) {
            return hash
        }

        for (i = 0; i < string.length; i++)
        {
            chr   = string.charCodeAt(i);
            hash  = ((hash << 5) - hash) + chr;
            hash |= 0 // Convert to 32bit integer
        }

        return hash
    }

    /**
     * Extracts table content from MarkDown and converts it into an entry with a MarkDown field
     * Entry is created if it doesn't already exist
     * @param table
     * @param copy
     */
    async function linkTableEntry(table, copy)
    {
        // extract MarkDown for the table from the entered text
        const pos      = table.position
        const strLen   = pos.end.offset - pos.start.offset
        const tableStr = copy.substr(pos.start.offset, strLen)
        const id       = createHash(tableStr) // avoid creating duplicate tables
        let   entry

        try {
            entry = await environment.getEntry(id)
        } catch (e) { }

        // create new entry since it doesn't exist yet
        if ('undefined' === typeof entry) {
            entry = await createTableEntry(tableStr, id)
        }

        return {
            nodeType: 'embedded-entry-block',
            content: [],
            data: {
                target: {
                    sys: {
                        type: 'Link',
                        linkType: 'Entry',
                        id: entry.sys.id
                    }
                }
            }
        }
    }

    /**
     * Creates a new Entry element with a string representing the table in MarkDown format
     * The table header is used as the title for the Entry
     * @param tablestring
     * @param id
     */
    async function createTableEntry(tablestring, id)
    {
         // create entry title from table header
        const title = tablestring
                        .match(/^.+|\n/g)[0]     
                        .split('|')
                        .filter(Boolean)         
                        .join(', ')
                        .replace(/\t/g, '')      
                        .replace(/[ ]+,/g, ', ') 
                        .replace(/[ ]+/g, ' ')   
                        .trim()

        let entry = await environment.createEntryWithId('table', id, {
            fields: {
                title: {
                    'de-DE': title
                },
                content: {
                    'de-DE': tablestring
                    }
                }
        })

        return await entry.publish()
    }

    migration.transformEntries({
        contentType: 'article',
        from: ['content'],
        to: ['contentV2'],
        transformEntryForLocale: async function(fromFields, currentLocale)
        {
            let copy = fromFields.content[currentLocale]

            const content = await richTextFromMarkdown(copy,
                async (node) => {
                    let ret = null
                    let didSomething = true

                    node.deriveLinkedEntries()

                    switch (node.type) {
                        case 'image':
                            // ...
                            break;
                        case 'html':
                            // ...
                            break;
                        case 'table':
                            ret = await linkTableEntry(node, copy)
                            break
                        default:
                            didSomething = false
                    }

                    if (false === didSomething) {
                        console.log(node)
                    }

                    return ret
                }
            )

            return {
                contentV2: {
                    nodeType: 'document',
                    content: content.content,
                    data: {}
                },
            }
        }
    })
}

In summary, here's what is happening in this code:

• I defined a new content model table with a title and a long text field content
• I utilized the positional information provided by richTextFromMarkdown() to extract the MarkDown string for the table from the content
• A simple hash is generated for the string to prevent duplicate table creation when rerunning the migration
• If the table already exists, it is included inline; if not, ContentFul's managementClient is used to create a new one on-demand
• By using the sys.id of this entry, we can insert a linked entry into the Rich Text field

I hope this explanation will be helpful to someone facing similar challenges with migrating tables from MarkDown to Rich Text in Contentful.