Using Dynamic to create and then flatten an arbitrarily-nested array
There's never any reason to use dynamic here at all.  You never use any of its features.  You could literally copy-paste all instances of it with object and the code would function identically.

Now, that's not a particularly good design for storing data like this.  If you actually want to store a tree of data you're better off with a more traditional tree setup.  Create a Node type, and let those nodes have both values and child nodes, which can themselves have child nodes, and so on.  You can then traverse that tree structure.  That makes it much clearer what's going on, rather than just seeing an object that you happen to just know is a tree structure where it contains either a sequence of other objects, or a value, and where each object in the sequence may itself be a sequence or a value.  It also means that when you create operations that work with these trees they can accept instances of those types, so people don't do weird things like pass in a string to your method here, only to have it crash, instead of just failing to compile.

As for the actual Flatten method, personally I'd prefer a non-recursive implementation.  Most significantly because the stack in C# just isn't that big, and it's not really all that uncommon to have tree structures that are deeper than the stack can support, resulting in you getting stack overflow exceptions.  It's a little bit easier code to write the recursive version for many people, but you're constraining yourself to only working with shallow trees by using it.

I'd also suggest making the Flatten method an iterator block.  There's no sense computing the entire value right from the start, when the underlying algorithm itself is inherently computing one value at the time.  Using an iterator block lets the consumer use each value as you compute it, and removes the need for you to do the work of computing values that may not be needed, and also prevents the entire result set from needing to be in memory all at once, assuming the resulting values can be processed one at a time (a common enough situation).