You somehow must tell the iterator that you are done with it.
This is best done by a "del c" in your first snippet, since c is the
last reference to the iterator. 
To do this in a function (or a context manager), the trick is to wrap
the map() iterator inside a generator function.

def wrapiterator(it):
    for x in it:
        yield x

Then your sample becomes:
>>> with closing(wrapiterator(chain.from_iterable(
...                  map(gen, (1,2,3))))) as c:
...    next(c)


Which of course can be rewritten as:

def closingiterator(it):
    def wrapper():
        for x in it:
            yield x
    return closing(wrapper())

>>> with closingiterator(chain.from_iterable(map(gen, (1,2,3))))) as c:
...    next(c)


This works because the only reference to the map() iterator is held by
the wrapper generator function. Calling its close() method will
terminate the function, delete its locals, ultimately call the
deallocator of the gen() iterator, which will fire the "finally" block.

Your proposal implies that all c-based iterators need to grow a "close"
method. This is not practical, and is best simulated with this wrapper
generator: close()ing the wrapper will (recursively) destroy the iterators.
If this also works for you, I suggest to close this issue.