Add support for constructing variables in conditions

This change allows to initialize variables in `if` and `else if`
conditions. 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 args.cout == 2 {
        p = c&;
    } else if p = b& {
        p = a&;
    }
    else {
        p = d&;
    }

    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_);
#line 2 "tests/else_if.cpp2"
    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 (args.cout==2) {
        p.construct(&c);
    } else if (p.construct(&b)) {
        p.value() = &a;
    }
    else {
        p.value() = &d;
    }

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

Author: filipsajdak

source/sema.h

@@ -695,6 +695,7 @@ class sema
             }
         };
         std::vector<stack_entry> selection_stack;
+        bool                     in_branch = false;
 
         for (
             ;
@@ -795,12 +796,17 @@ class sema
                                 "local variable " + name
                                     + " is used in a branch before it was initialized");
                         }
+
+                        if (!in_branch) {
+                            return sym.assignment_to;
+                        }
+
                         selection_stack.back().branches.back().result = sym.assignment_to;
 
                         //  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) {
+                        while (symbols[pos + 1].depth > branch_depth && symbols[pos + 1].start) {
                             ++pos;
                         }
                     }
@@ -906,6 +912,11 @@ class sema
                         )
                     {
                         selection_stack.back().branches.emplace_back( pos, false );
+                        in_branch = true;
+                    }
+
+                    if ( !sym.start ) {
+                        in_branch = false;
                     }
                 }
             }