Fixes #42645

This PR allows the use of `else` inside try-blocks, which is only taken
if no exception was caught inside `try`. It is still combinable with
`finally` as well.

If an error is thrown inside the `else` block, the current semantics are
that the error does not get caught and is thrown like normal, but the
`finally` block is still run afterwards. This seemed like the most
sensible option to me.

I am not very confident about the implementation of linearization for
`trycatchelse` here, so I would appreciate it if @JeffBezanson could
give this a thorough review, so that I don't miss any edge cases.

I thought we had an issue for this already, but I couldn't find
anything. `else` might also not be the best keyword here, so maybe we
can come up with something clearer. But it of course has the advantage
that it is already a Julia keyword, so we don't need to add a new one.

Co-authored-by: Jeff Bezanson <[email protected]>

#42669)

We have a swpacols! helper in Base that is used in the permuation
code as well as in the bareiss factorization code. I was working
on extending the latter, among others to sparse arrays and
alternative pivot choices. To that end, this PR, adds swaprows!
in analogy with swapcols! and adds optimized implementations for
SparseMatrixCSC. Note that neither of these functions are currently
exported (though since they are useful, we may want a generic
swapslices! of some sort, but that's for a future PR).

While we're at it, also replace the open-coded in-place circshift!
by one on SubArray, such that they can automatically beneift
if that method is optimized in the future (#42676).

codegen: add missing jl_get_fieldtypes calls

...by removing unnecessary type checks/assertions. This basically
restores the function bodies to what they looked like prior to #40594
and only keeps the changed signatures (with the additional changes to
circumvent #39088.

Support for building MSVC and ICC was removed from the build system in
PR #42586; this patch removes more leftover code which was there to
support MSVC / ICC.

Adds the sentence @JeffBezanson proposed to the documentation and solves #30824.

Co-authored-by: Dilum Aluthge <[email protected]>

The PR #38905 only "back-propagates" conditional constraint
(from callee to caller), but currently we don't "forward" it
(caller to callee), and so inter-procedural constraint propagation
won't happen for e.g.:
```julia
ifelselike(cnd, x, y) = cnd ? x : y
@test Base.return_types((Any,Int,)) do x, y
    ifelselike(isa(x, Int), x, y)
end |> only == Int
```

This commit complements #38905 and enables further inter-procedural
conditional constraint propagation by forwarding `Conditional` to
callees when it imposes a constraint on any other argument,
during constant propagation.

- remove `const_prop_rettype_heuristic` since it handles rare cases,
  where const-prop' doens't seem to be worthwhile, e.g. it won't be
  so useful to try to propagate `Const(Tuple{DataType,DataType})` for
  `Const(convert)(::Const(Tuple{DataType,DataType}), ::Tuple{DataType,DataType} -> Tuple{DataType,DataType}`
- rename `is_allconst` to `is_all_overridden`
- also minor refactors and improvements added