port QuarkChain slavechain (MinorBlock) types, storage and chain plumbing

[blockchaindevsh]

Addresses #1 and #7.

Summary

This PR makes goshard/base support the QuarkChain slavechain
(shardchain) block and header as defined in goquarkchain,
ported as a parallel qkc/ package tree (~14k lines, 75 Go files). The
port is byte-compatible: headers and blocks serialize and hash exactly as in
goquarkchain (keccak256(serialize(header)), not RLP), and the storage
layer uses the identical on-disk key schema.

The root chain is not implemented here — it keeps running on the
original goquarkchain code; root block types are ported only as passive
dependencies and PrevRootBlockHash anchoring is validated against externally supplied
root blocks. Transaction execution is intentionally deferred (see Next
steps).

What's included

Package	Content
qkc/serialize	QuarkChain's reflection-based binary codec
(verbatim, stdlib-only)
qkc/account	Branch (fullShardId codec), Address, Identity +
python golden testdata
qkc/common (+hexutil)	helpers, token-id codec, QKC hexutil fork
(lenient leading zeros)
qkc/params, qkc/config	QKC EVM constants;
cluster/chain/shard/root configuration (JSON-identical)
qkc/types	MinorBlock/MinorBlockHeader/MinorBlockMeta,
Transaction+EvmTransaction, Receipt, Log, Bloom,
TokenBalances, CalculateMerkleRoot, passive RootBlock
qkc/core/rawdb	minor/root block accessors, canonical/head pointers
— on-disk compatible
qkc/consensus (+doublesha256)	CommonEngine framework, difficulty
calculator, real double-sha256 PoW
qkc/core	structural MinorBlockChain, genesis,
MinorBlockValidator
cmd/qkcshard	standalone multi-shard runner (goquarkchain-slave
shape) + README

Byte/disk compatibility proof

All locked by goquarkchain's own golden vectors, ported with the code:
header hash b0b7dfab…9153d869, the 479-byte header size, the
token-trie root 0x848d4271…, CalculateMerkleRoot, RootBlock hash + signature, full
round-trips for every type, and the python-generated account/config
testdata.

Architecture

Parallel tree with minimal sharing: only geth's type-agnostic layers
are imported (crypto, rlp, common, ethdb, trie/triedb, log,
event, lru, params.ChainConfig as a type). geth's mainnet core/*,
consensus, Engine API, eth and miner are untouched, keeping the tree
upstream-mergeable.
Compile-level adaptations only (e.g. sha3.NewKeccak256 →
crypto.NewKeccakState,
modern trie constructors); no logic or format changes.

Entry point

go run ./cmd/qkcshard --mine --blocks 3                          #
in-memory demo
go run ./cmd/qkcshard --datadir /data/slave0 --fullshardid 2,3 --mine

One database per shard (/shard-0xN), idempotent genesis, engine
selected per shard from CONSENSUS_TYPE (real PoW for POW_DOUBLESHA256,
timed production otherwise). See cmd/qkcshard/README.md.

Testing

go test ./qkc/... — 8 packages green (golden vectors, rawdb round-trips,
genesis determinism, import/side-fork/orphan handling, database reopen,
real PoW mine-and-verify). go build ./... stays green tree-wide.

Next steps: integrating geth StateDB & EVM

Execution is the follow-up work item; every removed piece is marked
TODO(execution-issue) (20 seams). geth's core/state and core/vm are
type-agnostic and will be imported, not copied:

1. State wiring: add stateCache to MinorBlockChain via
   state.NewMPTDatabase(triedb.NewDatabase(db, nil), state.NewCodeDB(db));
   implement State()/StateAt(root); genesis state-from-alloc replacing the
   empty-root placeholder; two-step persistence
   (statedb.Commit(...) + triedb.Commit(root, ...)) with trie GC in
   WriteBlockWithState.
2. EVM execution: a qkc/core state processor — one vm.NewEVM per block
   with a vm.BlockContext built from MinorBlockHeader; per tx convert
   EvmTransaction → core.Message → core.ApplyMessage, assemble qkc
   Receipts; engine Finalize credits the coinbase.
3. Validation completion: the seamed ValidateState checks (gas used,
   xshard cursor, coinbase amount, state root) and reorg-with-state.
4. Pending decision — account/token model: single native token (reuse
   geth state unmodified) vs faithful multi-token semantics (fork core/state
   under qkc/ plus the QKC native-token precompiles and fullShardKey-aware
   CreateAddress). Block/header hashing is unaffected either way.
5. Afterwards: txpool + miner template (blocks with real transactions),
   PoSW difficulty adjustment.

Note: goquarkchain's testBranch.json golden-vector file (160k
brute-force random vectors per shard size, 33MB) is deterministically sampled to 100
entries per shard size (1,600 total, all 16 shard sizes covered); the full
set was validated green once during the port.

[qzhodl]

Two things for this PR:

• Too big to review well. It splits cleanly into a dependency-ordered stack of smaller PRs (serialize → common/account/config → types → rawdb → consensus → core), each with its own tests.

• Mining shouldn't live in main. Both pyquarkchain and goquarkchain keep it as a separate module (internal miner + external RPC miner), not inlined into the entry point. The current cmd/qkcshard looks more like an e2e test.