Sigh. Please don't conflate syntax with semantics.
TL;DR: A continuation is a reference to a point of evaluation. Your "continuation" reporter is only hidden in the display of the continuation object, this is to let you know that you can call that continuation and pass a parameter in lieu of the reporter. Syntax operations generate a separate, context-free copy of the blocks, including the hidden one.
Long version:
A continuation is a special kind of function that you can call. It is special, because similar to a closure it captures certain state of the context function it has been created in. The continuation of a reporter is the the input slot it's embedded in, and after the input slot it's the other input slots to the right of the current one, then the block which those input slots belong to, and then the next command block after that block, and so on. Because the continuation is the input slot we're visualizing the continuation as a ring (an anonymous function) around the parent script with the input slot (= "continuation") left blank, so it becomes an implicit input of the ring, i.e. you can call it with a parameter in lieu of the reporter whose continuation you capture. That's a visualization, in other words, we show you something that we hope you recognize, in this case a ring with an empty input slot, and we expect you to then know how to use it (call it with an input that gets mapped to the empty slot). But it's still a visualization, and abstraction, because in reality the whole continuation would be a very, very, complicated and often extremely long and funny looking script (just think about what it would look like to capture a continuation inside a bunch of - nested - loops). As with closures there is more to the object than those blocks we're showing you, state that isn't visualized (and there is always debate whether more state should be visualized). When you join a ring, what exactly do you expect? joining - like splitting - rings operates on the syntax of a ring, and strips away all semantic "überbau", including the visualization of the empty-slot-means-implicit-parameter mechanism. So what you then get is the parent script including all its components. And the reason you're getting the reporter is that the continuation doesn't actually produce a new function but captures an entry point to a stackframe in the evaluator. It's not a regular function (and you can't persist it in the project), but a reference. As such it cannot "strip" stuff away, only hide it in the visualization. When you turn such and object into syntax you get a new ring whose blocks are no longer references but actual, hard, code. And you also get the hidden parts.
I'm not very excited about this whole discussion. Every time someone on this forum uses metaprogramming a mind-blossom withers and a baby function starves to death. Like I pointed out above, you might be misunderstanding - or reading way too much into - continuations. There is a Continuations library, it demonstrates how to use this feature, please just use that!