mux: codec-agnostic PictureInfo + provenance; measure field order, never guess

Carry per-picture truth and byte-exact source provenance THROUGH the stream so
the muxer (and the upcoming video index) read MEASURED facts instead of
assuming them. Honest data in, honest data out.

- codec/coding.rs: codec-agnostic PictureInfo (CodingType / FieldOrder + the
  accessors field_order/coding_type/nb_fields/progressive/keyframe). Each codec
  folds its raw signals in; consumers use only accessors, never branch on codec.
- mpeg2: builds PictureInfo from the picture coding extension and carries it +
  SourcePos (source_marks, parallel to pts_marks) on every emitted frame.
- pes / codec::Frame: additive `coding` + `source`, forwarded through the
  highway; None for audio/subtitle and the network/stdio deserialize hop.
- mkvstream: DEFER muxer construction until the first coded picture, set the
  video track's FieldOrder from the MEASURED value, THEN write the header —
  right the first time, no guess, no seek-back. An interlaced track that arrives
  with no measured order is LOGGED loudly and left UNDETERMINED, never faked.
- mkv: MkvTrack::video no longer guesses TFF (a bitstream property the scan
  cannot know is UNDETERMINED at build). Removed VideoStream::top_field_first
  (the dead scan-time guess) crate-wide.
- Tests: parser population (every PictureInfo facet + per-PES source carry) and
  mux-stream consumption (measured -> correct; missing -> UNDETERMINED, not
  faked). Two obsolete tests updated only after confirming (their own comments)
  they existed to enforce the deleted hardcoded-TFF.

src/mux/demux_thread.rs

@@ -142,9 +142,13 @@ impl DemuxThread {
                         None
                     };
                     let n = buf.len();
+                    // Source byte offset of this buffer's first byte = bytes fed
+                    // so far. Threaded into the demuxer so every PES it cuts is
+                    // stamped with its SourcePos (carried, not reconstructed).
+                    let buf_base = fed_bytes;
                     fed_bytes += n as u64;
                     if let Some(ref mut d) = ts {
-                        let pkts = d.feed(&buf);
+                        let pkts = d.feed_at(buf_base, &buf);
                         let t2 = if prof {
                             Some(std::time::Instant::now())
                         } else {
@@ -191,7 +195,7 @@ impl DemuxThread {
                             }
                         }
                     } else if let Some(ref mut d) = ps {
-                        let pkts = d.feed(&buf);
+                        let pkts = d.feed_at(buf_base, &buf);
                         let _ = recycle_tx.send(buf);
                         // Always send (even empty) — same early-disconnect
                         // detection rationale as the TS branch above.