Add support for nested ifs/else-ifs

This change brings support for nested `if` or `else if`.
It make possible to process the following code:
```cpp
main: (args) = {
    p : *int;

    a := 1;
    b := 2;
    c := 3;
    d := 4;

    if args.cout == 3 {
        p = a&;
    } else if p = b& {
        if args.cout == 2 {
            p = c&;
        } else {
            if b > 0 {
                p = a&;
            }
            else {
                p = d&;
            }
        }
    } else {
        p = c&;
    }

    std::cout << p* << std::endl;
}
```
And gets generated:
```cpp
auto main(int const argc_, char const* const* const argv_) -> int{
    auto args = cpp2::make_args(argc_, argv_);
    cpp2::deferred_init<int*> p;

    auto a {1};
    auto b {2};
    auto c {3};
    auto d {4};

    if (args.cout==3) {
        p.construct(&a);
    } else if (p.construct(&b)) {
        if (args.cout==2) {
            p.construct(&c);
        }else {
            if (cpp2::cmp_greater(std::move(b),0)) {
                p.construct(&a);
            }
            else {
                p.construct(&d);
            }
        }
    }else {
        p.construct(&c);
    }

    std::cout << *cpp2::assert_not_null(std::move(p.value())) << std::endl;
}
```

Assignements are properly marked as `DEFINITE INITIALIZATION`

```
  0 | function main
  1 |   scope
  2 |     var p *** UNINITIALIZED
  2 |     /var
  2 |     var a
  2 |     /var
  2 |     var b
  2 |     /var
  2 |     var c
  2 |     /var
  2 |     var d
  2 |     /var
  2 |     selection
  3 |       if branch
  4 |         *** (10,9) DEFINITE INITIALIZATION OF p
  4 |         *** use of a
  4 |         /if branch
  3 |       *** (11,15) DEFINITE INITIALIZATION OF p
  3 |       *** use of b
  3 |       if else branch
  4 |         selection
  5 |           if branch
  6 |             *** (13,13) DEFINITE INITIALIZATION OF p
  6 |             *** (13,17) DEFINITE LAST POTENTIALLY MOVING USE OF *** use of c
  6 |             /if branch
  5 |           else branch
  6 |             selection
  7 |               *** (15,16) DEFINITE LAST POTENTIALLY MOVING USE OF *** use of b
  7 |               if branch
  8 |                 *** (16,17) DEFINITE INITIALIZATION OF p
  8 |                 *** (16,21) DEFINITE LAST POTENTIALLY MOVING USE OF *** use of a
  8 |                 /if branch
  7 |               else branch
  8 |                 *** (19,17) DEFINITE INITIALIZATION OF p
  8 |                 *** (19,21) DEFINITE LAST POTENTIALLY MOVING USE OF *** use of d
  8 |                 /else branch
  7 |               /selection
  6 |             /else branch
  5 |           /selection
  4 |         /if else branch
  3 |       else branch
  4 |         *** (23,9) DEFINITE INITIALIZATION OF p
  4 |         *** (23,13) DEFINITE LAST POTENTIALLY MOVING USE OF *** use of c
  4 |         /else branch
  3 |       /selection
  2 |     *** (26,18) DEFINITE LAST POTENTIALLY MOVING USE OF *** use of p
  2 |     /scope
  1 |   /function

```

Author: filipsajdak

source/sema.h

@@ -683,6 +683,8 @@ class sema
                 branch(int s, bool r) : start{s}, result{r} { }
             };
             std::vector<branch> branches;
+            bool in_branch = false;
+            int initialized_in_condition_pos = -1;
 
             stack_entry(int p) : pos{p} { }
 
@@ -695,7 +697,6 @@ class sema
             }
         };
         std::vector<stack_entry> selection_stack;
-        bool                     in_branch = false;
 
         for (
             ;
@@ -755,33 +756,23 @@ class sema
 
                     //  Else if we're inside a selection statement but still in the condition
                     //  portion (there are no branches entered yet)
-                    else if (std::ssize(selection_stack.back().branches) == 0) {
-                        //  If this is a top-level selection statement, handle it the same as
-                        //  if we weren't an a selection statement
-                        if (std::ssize(selection_stack) == 1) {
+                    else if (!selection_stack.back().in_branch) {
                             if (sym.assignment_to) {
                                 definite_initializations.push_back( sym.identifier );
+                                selection_stack.back().initialized_in_condition_pos = pos;
                             }
                             else {
                                 errors.emplace_back(
                                     sym.identifier->position(),
                                     "local variable " + name
                                         + " is used in a condition before it was initialized");
                             }
-                            return sym.assignment_to;
-                        }
-                        //  Else we can skip the rest of this selection statement, and record
-                        //  this as the result of the next outer selection statement's current branch
-                        else {
-                            selection_stack.pop_back();
-                            assert (std::ssize(selection_stack.back().branches) > 0);
-                            selection_stack.back().branches.back().result = sym.assignment_to;
 
-                            int this_depth = symbols[pos].depth;
-                            while (symbols[pos + 1].depth >= this_depth) {
+                            int branch_depth = symbols[selection_stack.back().pos].depth;
+                            while (symbols[pos + 1].depth > branch_depth) {
                                 ++pos;
                             }
-                        }
+                            --pos; // to handle end of if/else branch
                     }
 
                     //  Else we're in a selection branch and can skip the rest of this branch
@@ -797,7 +788,7 @@ class sema
                                     + " is used in a branch before it was initialized");
                         }
 
-                        if (!in_branch) {
+                        if (!selection_stack.back().in_branch) {
                             return sym.assignment_to;
                         }
 
@@ -806,7 +797,11 @@ class sema
                         //  The depth of this branch should always be the depth of
                         //  the current selection statement + 1
                         int branch_depth = symbols[selection_stack.back().pos].depth + 1;
-                        while (symbols[pos + 1].depth > branch_depth && symbols[pos + 1].start) {
+                        while (symbols[pos + 1].depth > branch_depth + 1
+                            || (
+                                symbols[pos + 1].depth == branch_depth + 1 && symbols[pos + 1].start
+                            )
+                        ) {
                             ++pos;
                         }
                     }
@@ -831,6 +826,7 @@ class sema
 
                     auto true_branches  = std::string{};
                     auto false_branches = std::string{};
+
                     for (auto const& b : selection_stack.back().branches)
                     {
                         //  If this is not an implicit 'else' branch (i.e., if lineno > 0)
@@ -845,9 +841,13 @@ class sema
                         }
                     }
 
+                    if (auto init_pos = selection_stack.back().initialized_in_condition_pos; init_pos != -1) {
+                        true_branches += "\n  branch condition starting at line "
+                                    + std::to_string(symbols[init_pos].position().lineno);
+                    }
+
                     //  If none of the branches was true
-                    if (true_branches.length() == 0)
-                    {
+                    if (true_branches.length() == 0) {
                         selection_stack.pop_back();
                         //  Nothing else to do, just continue
                     }
@@ -912,11 +912,11 @@ class sema
                         )
                     {
                         selection_stack.back().branches.emplace_back( pos, false );
-                        in_branch = true;
+                        selection_stack.back().in_branch = true;
                     }
 
                     if ( !sym.start ) {
-                        in_branch = false;
+                        selection_stack.back().in_branch = false;
                     }
                 }
             }