Recurse into if/try branches for explicit returns

Currently Runic will format something e.g.

function foo()
    if condition
        x
    else
        y
    end
end

into

function foo()
    return if condition
        x
    else
        y
    end
end

However, looking at some real world code examples of this it seems that about 50% of the time returning whatever value comes out of the if is not intended and adding return after the block is a better "fix". e.g.

function foo()
    if condition
        x
    else
        y
    end
    return
end

and around 50% or the time it is better to insert the returns inside the branches, e.g.

function foo()
    if condition
        return x
    else
        return y
    end
end

Some potential changes to the current setup:

If there are no return in any branch recurse and add returns in the branches instead of putting the return in front of the whole block. The question would then be if Runic should also add an explicit else branch when no such branch exist, e.g.
```
function foo()
   if condition
       x
   end
end
```
would become
```
function foo()
   if condition
       return x
   else
       return
   end
end
```
If there are return in any branch, make sure there is a return in all branches.

The same discussion applies to try, but for try it can actually improve readability a bit too since it isn't obvious what the possible return values are in e.g.

function foo()
    try
        rand() < 0.5 && error("error")
        "try_value"
    catch err
        "catch_value"
    else
        "else_value"
    finally
        "finally_value"
    end
end

so making it explicit is a good idea, e.g.

function foo()
    try
        rand() < 0.5 && error("error")
        "try_value"
    catch err
        return "catch_value"
    else
        return "else_value"
    finally
        "finally_value"
    end
end

fredrikekre / Runic.jl

Recurse into if/try branches for explicit returns #52