Use arshal flags instead of coder flags

[dsnet]

Instead of consulting the flags on the coder via:

export.Encoder(enc).Flags
export.Decoder(dec).Flags

consult flags on the call-provided arshal options via:

mo.Flags
uo.Flags

This avoids unnecessarily peaking at the internals flags
of Encoder or Decoder and also allows us to simplify
some flag checking logic.

For example, the following are all equivalent:

export.Encoder(enc).Flags.Get(Foo) || mo.Flags.Get(Bar)
mo.Flags.Get(Foo) || mo.Flags.Get(Bar)
mo.Flags.Get(Foo | Bar)

A similar transform can also be done by applying
De Morgan's law to the following:

!export.Encoder(enc).Flags.Get(Foo) && !mo.Flags.Get(Bar)
!mo.Flags.Get(Foo) && !mo.Flags.Get(Bar)
!!(!mo.Flags.Get(Foo) && !mo.Flags.Get(Bar))
!(mo.Flags.Get(Foo) || mo.Flags.Get(Bar))
!(mo.Flags.Get(Foo | Bar))
!mo.Flags.Get(Foo | Bar)

There should be no behavior changes as a result of this
since the arshal option flags should be an exact
superset of the coder option flags.

There are 6 entry points to the "json" package:

• Marshal
• MarshalWrite
• MarshaEncode
• Unmarshal
• UnmarshalRead
• UnmarshalDecode

4 of them (Marshal, MarshalWrite, Unmarshal, UnmarshalRead)
obtain a coder from an internal pool,
where the arshal options plumbed down the call stack
is a pointer to the one inside the coder.
Therefore, there is no behavior difference for these 4 calls.

2 of them (MarshalEncode, UnmarshalDecode) take in a
user-provided coder, where there could theoretically
be a difference between the options struct and the coder options.
However, in both functions, we obtain a jsonopts.Struct locally
from an internal pool and then call jsonopts.Struct.CopyCoderOptions
where the coder options are copied from the user-provided coder
into the local jsonopts.Struct. Thus, the options struct that
we plumb down the stack is gauranteed to be a superset of
the options in the user-provided coder.