Round decimal division of tuple elements.

When performing tuple division, the floating point representation of
decimal divisors may yield surprising results.  For example, the
following expression

  >> 1.1.1 / 0.1

can return 9.9.9 or 10.10.10 depending on the host platform.

To address such discrepancies, `round(3)` before casting the result of
tuple element division to a `REBINT`; this should improve cross-platform
consistency.
Use R3's rounding implementation instead of round(3).

This should ensure greater portability as `round(3)` was standardised as
part of C99.
Permit SET-WORD! as the argument to COPY and SET in PARSE (CC #2023)
IF, EITHER, and UNLESS accept all values in then/else slots (CC #2063)

Conflicts:
	src/core/n-control.c
Fix PARSE position capture combined with SET or COPY

The recent extension to allow set-word! usage in SET and COPY rules
introduced a regression: set-word!s (for position capture) in the rule
immediately following a `SET word` or `COPY word` rule cause a match
failure. For example:

    >> parse [x] [set val pos: word!]
    == false  ;; Expected: true

This commit fixes this issue (CureCode issue 2130), a regression caused
by 8db79a9.

Corresponding tests have been added to the test suite
(rebolsource/rebol-test@fe8df53).

Conflicts:
	src/core/u-parse.c
Per @earl, don't add R_ARG4 for IF/ELSE (which we don't like anyway)

Conflicts:
	src/boot/natives.r
Incorporate /ONLY option for suppressing conditional block evaluation.
TO LOGIC! treats all non-none non-false values as true (CC #2055)

Conflicts:
	src/core/t-integer.c
Style: don't use additional block scopes
Make DO binary treat the binary as source

LOAD and IMPORT treat binary data as UTF-8 source. So should DO.

Also, fixes an outdated comment.

Conflicts:
	src/core/n-control.c
Correctly close IO device

A REBDEV pointer was passed in and treated as a REBREQ pointer. Address
Sanitizer complained invalid memory read.
Move integer arithmetic operations into their own functions

Such that they can be used elsewhere. Also makes it possible to take
advantages of builtin functions provided by compilers like clang.
Rework on the multiplication overflow detection

Do not reply on the production, because it's undefined when it overflows
Add two more constants
Use macros for overflow detection
Fix a use-after-free

It occurrs when:
1. Fetch_Buf
2. Read_IO
3. SIGINT
4. Signal_Handle
5. Put_Str, which modifies Std_IO_Req.data to the newly allocated string
"[escaped]"
6. Signal_Handle frees the string
7. Read_IO returns
8. Fetch_Buf tries to access Std_IO_Req.data, which now points to a
free'd string

Fix this by not modifying Std_IO_Req.data at all.
Insert a noop after interrupt is caught

Upon an intterrupt, an ESCAPE signal will be sent to the evaluator,
which causes the evaluation of next unit to be escaped.
>> (Ctrl+C)[escape]
>>q (this is ignored due to escape signal)
>>q (this quits)

With this change, it becomes:
>> (Ctrl+C)[escape]
does[] (automatically inserted, and ignored)
>> >>q (this quits)