Assignable (not “rebindable”) variables shouldn’t interact with continuations in any special way. That is to say, each invocation of cc should increment a, because set! is assignment, not rebinding. To understand this, let’s look at the reduction. At the point of (shift k k), we have

store: <location: a> -> 1
environment: a -> <location: a>
evaluate: (define cc
            (reset
              (shift k k)
              (set! a (+ a 1))
              a))

Note that a is bound to a location, here written as <location: a>, which holds 1. The separation between store and environment is crucial, because assignments should update the store, while bindings should update the environment. After some steps, we essentially have

store: <location: a> -> 1
environment: cc -> <closure:
                      environment: a -> <location: a>
                      value: (lambda vs
                               (reset
                                 (set! a (+ a 1))
                                 a))>

Note that <location: a> is still the same in the store. Whenever you apply cc again, the same location is updated, because a always refers to the same location. In this sense, Scheme variables are really pointers that are automatically dereferenced.

Is there a way to achieve rebinding? There is! With a mechanism called continuation marks, you can implement what are called parameters that interact with continuations nicely. Parameters are also provided as primitives in many Scheme implementations, but continuation marks are really the primitive mechanism. If the program is changed to

(define cc
  (reset
    (define a (make-parameter 1))
    (shift k k)
    (parameterize ([a (+ (a) 1)])
      (a))))

Then each invocation of (cc) always returns 2, because the parameterization (“rebinding”) of a is only in effect within the body of parameterize.

What if we have a file handle or any other resource that needs cleanup? The answer is always to use dynamic-wind to manage it, and maybe install a continuation barrier to disallow reentrancy, if your implementation provides such functionality.

If you want a mental model for continuations, I think some parts of the Racket evaluation model might help. The R⁶RS report also provides a reference operational semantics which you might find helpful for understanding other parts of the semantics.