Is there a 'string stack' data structure that supports these string operations?
I thought for quite some time, but didn't find the problem with doing all of your operations in the most stupid possible way in a trie-like DAG structure:
Add-Prefix-Set
Create a trie of strings from $T$. Connect each leaf node to the root of the old trie.
Complexity: $O(|T|)$
Merge
Unite roots of two structures: make all children nodes of the second root children of the first node. You may now have multiple edges marked with the same character going from the same node.
Complexity: $O(1)$
Lazy update of the root

For each character unite all children of the root accessible by the edges marked with this character. ($O(|\Sigma|)$ + Amortized $O(1)$ for each edge ever added)
Delete all edges going into the root from the top. (Can happen after Remove-prefixes, amortized $O(1)$ for each edge ever added)

Get-prefixes
Lazy update the root. Now find all children of the root and report set of letters on edges going to them.
Complexity: $O(|\Sigma|)$
Remove-prefixes
Lazy update the root. Unite all children of the root and set the root pointer to the result of this unite. Lazy update the new root.
Complexity: $O(|\Sigma|)$ + Lazy update
Persistence
All information about this data structure can be saved in arrays, with $O(1)$ information per node plus $O(|\Sigma|)$ information for each child of the node. Each operation can be held out as set of assignments in these arrays. Use persistent range tree or any other data structure that can be viewed as a persistent array. Additional multiplier for memory and space complexity $O(log N)$, where $N$ is the total number of characters in all queries.