fix(pcapng): resolve byte order for a raw bytes option without self._byte set (#2353)

An option or record handed to a block maker as raw bytes has its type code read
back out of those octets, in the block's byte order -- which only
`_make_block_shb` and `_make_block_systemd` set. A raw option in any other
block, and a raw record in an NRB, therefore raised `AttributeError: 'PCAPNG'
object has no attribute '_byte'`.

`make` now settles the byte order before the block maker runs, the way `pack`
settles it: the section's, else the one the packet data declares, else the
host's. A section header block still overrides it from its own Byte-Order
Magic. Settling it here covers every block maker: `_make_block_shb` and
`_make_block_systemd` settle their own, and without this the rest read an
attribute that is not there.

`__packet__` handed over as `None` degrades to no packet data, matching how
`Schema.pack` already treats it, rather than raising a `TypeError`.

Tested by a unit module: a raw option and a raw record build with no byte
order set, each block parses back from its own octets and rebuilds byte for
byte, the code resolved is pinned through the "only one of this option" guard
in a big-endian section as well as a little-endian one, a bound section
outranks a byte order the packet data declares, a byte order declared one
level up inside `__packet__` is read correctly, and `__packet__=None` resolves
to the host order instead of raising.

Fail-without-fix: 10 test methods, 16 failures on `origin/main`.

Author: JarryShaw

pcapkit/protocols/misc/pcapng.py

@@ -64,6 +64,7 @@
 from pcapkit.const.pcapng.verdict_type import VerdictType as Enum_VerdictType
 from pcapkit.const.reg.linktype import LinkType as Enum_LinkType
 from pcapkit.corekit.enum import EnumLookup
+from pcapkit.corekit.fields.byteorder import packet_byteorder
 from pcapkit.corekit.fields.strings import DecodedString
 from pcapkit.corekit.infoclass import OrderedMultiInfo
 from pcapkit.corekit.io import advance
@@ -1457,6 +1458,27 @@ def make(self,
                                          reversed=type_reversed, pack=False))
         self._type = type_val
 
+        # NOTE: An option or record handed over as raw octets has its type code
+        # read back out of them -- by ``_make_pcapng_options`` and
+        # ``_make_nrb_records`` -- in the byte order the block is written in. So
+        # the byte order has to be settled before the block maker runs, not only
+        # after it as ``pack`` settles it, and settled the way ``pack`` settles
+        # it, so that the code read matches the octets emitted. Settling it here
+        # covers every block maker: ``_make_block_shb`` and
+        # ``_make_block_systemd`` settle their own, and without this the rest
+        # read an attribute that is not there (#2353). A section header block
+        # overrides this from its own Byte-Order Magic, it being the block that
+        # starts the section read here.
+        #
+        # ``or {}`` rather than a ``get`` default because ``__packet__`` may be
+        # handed over explicitly as :data:`None`, which is what
+        # :meth:`Schema.pack <pcapkit.protocols.schema.schema.Schema.pack>`
+        # takes for "no packet data" as well.
+        if self._ctx is not None:
+            self._byte = self._ctx.section.byteorder
+        else:
+            self._byte = packet_byteorder(kwargs.get('__packet__') or {})
+
         if isinstance(block, bytes):
             block_val = block  # type: bytes | Schema_BlockType
         elif isinstance(block, (dict, Data_PCAPNG)):