Complete FSharp.Linq.RuntimeHelpers.LeafExpressionConverter.QuotationToExpression

It is especially unexpected when
```fs
Linq.RuntimeHelpers.LeafExpressionConverter.QuotationToLambdaExpression <@ System.Func(fun x -> System.Console.WriteLine "1"; System.Console.WriteLine "2"; x) @>
```
fails with
```fs
System.NotSupportedException: Could not convert the following F# Quotation to a LINQ Expression Tree
--------
Sequential (Call (None, WriteLine, [Value ("1")]),
Sequential (Call (None, WriteLine, [Value ("2")]), x))
-------------
```
when `System.Linq.Expressions.Expression.Block` is available.

`VarSet` is also not convertible despite the existence of `System.Linq.Expressions.Expression.Assign`.

Ditto `PropertySet`, `FieldSet`, `TryWith`, `TryFinally`, `ForIntegerRangeLoop`, and `WhileLoop`.

The existing way of approaching this problem in F# is hand-building expressions without using quotations.

Are there expressions that are unconvertible from quotations to expressions instead of just not being implemented?

`raise` and `reraise` should be treated as special functions and be converted to special expressions just like conversion operators as well.

## Pros and Cons

The advantages of making this adjustment to F# are
1. Enabling more efficient reflection-based code
2. Allowing more uses of quotations to compile code on-the-fly

The disadvantages of making this adjustment to F# are none?

## Extra information

Estimated cost (XS, S, M, L, XL, XXL): S to M

Related suggestions: (put links to related suggestions here)

## Affidavit (please submit!)

Please tick this by placing a cross in the box:
* [x] This is not a question (e.g. like one you might ask on [stackoverflow](http://stackoverflow.com)) and I have searched stackoverflow for discussions of this issue
* [x] I have [searched both open and closed suggestions on this site](http://github.com/fsharp/fslang-suggestions/issues) and believe this is not a duplicate
* [x] This is not something which has obviously "already been decided" in previous versions of F#. If you're questioning a fundamental design decision that has obviously already been taken (e.g. "Make F# untyped") then please don't submit it.

Please tick all that apply:
* [x] This is not a breaking change to the F# language design
* [x] I or my company would be willing to help implement and/or test this

## For Readers

If you would like to see this issue implemented, please click the :+1: emoji on this issue. These counts are used to generally order the suggestions by engagement.

Start at LeafExpressionConverter.QuotationToExpression and review how quotation nodes are mapped to LINQ expression trees. Compare the listed unsupported constructs with the available Expression APIs, including Block, Assign, exception handling, loops, and special handling for raise and reraise. Done means the supported cases convert successfully and are covered by tests.

Written by the indexing model from the issue text.