Add a @finalize decorator for functions to collect/operate on subroutine results.

[bckohan]

For symmetry with @initialize

This behavior is mostly currently achievable with result_callback that you can pass to Typer.callback or Typer.group. There are two deficiencies:

1. The command must be compound. There's no way to finalize a singular command. This makes sense, but it'd be nice if the interface uniformly worked.
2. result_callback is not class aware, so you have to jump through extra hoops to get access to self - namely you need to return it from your subcommands.

[bckohan]

You can currently do something like this, but its very awkward:

class Command(TyperCommand):

    def finalize(self, **kwargs):
        pass

    @initialize(result_callback=finalize)
    def init(self):
        pass

    @command():
    def cmd(self):
        return self

Or this for chainable commands:

class Command(TyperCommand, chain=True):

    @staticmethod
    def finalize(result, **kwargs):
        self = result[0]

    @initialize(result_callback=finalize)
    def init(self):
        pass

    @command():
    def cmd1(self):
        return self

    @command():
    def cmd2(self):
        return self

Would prefer to be able to do something like:

class Command(TyperCommand, chain=True|False):

    @finalize()
    def finalize(self, results):
        pass

    @initialize()
    def init(self):
        pass

    @command():
    def cmd(self):
        return self