text: Title: (Not an issue right now) Handle multiple returns
  Body: ~~I'll try to work on this relatively soon, but~~ to think out loud..
  
  In interprocedural_cfg.py, we have 
  
  ```python
  def return_handler(self, node, function_nodes):
      """Handle the return from a function during a function call."""
      call_node = None
      for n in function_nodes:
          if isinstance(n, ConnectToExitNode):
              LHS = CALL_IDENTIFIER + 'call_' + str(self.function_index)
              previous_node = self.nodes[-1]
              if not call_node:
                  RHS = 'ret_' + get_call_names_as_string(node.func)
                  r = RestoreNode(LHS + ' = ' + RHS, LHS, [RHS],
                                  line_number=node.lineno,
                                  path=self.filenames[-1])
                  call_node = self.append_node(r)
                  previous_node.connect(call_node)
          else:
              # lave rigtig kobling
              pass
  ```
  
  which cleaned is 
  
  ```python
  def return_handler(self, call_node, function_nodes):
      """Handle the return from a function during a function call.
  
      Args:
          call_node(ast.Call) : The node that calls the definition.
          function_nodes(list[Node]): List of nodes of the function being called.
      """
      for node in function_nodes:
          # Only Return's and Raise's can be of type ConnectToExitNode
          if isinstance(node, ConnectToExitNode):                
              # Create e.g. ¤call_1 = ret_func_foo RestoreNode
              LHS = CALL_IDENTIFIER + 'call_' + str(self.function_call_index)
              RHS = 'ret_' + get_call_names_as_string(call_node.func)
              return_node = RestoreNode(LHS + ' = ' + RHS,
                                        LHS,
                                        [RHS],
                                        line_number=call_node.lineno,
                                        path=self.filenames[-1])
              self.nodes[-1].connect(return_node)
              self.nodes.append(return_node)
              return 
  ```
  
  Firstly, the for loop and the if statement seem to just serve the purpose of "Is there a node of type Return or Raise in the function?" But I think all functions should have at least one return node, right? I'm not sure if I understand the original intention that well e.g. what was going to be in the else?
  
  Secondly, here is an example to illustrate the problem/need to handle multiple returns:
  
  TODO