Turns ruleset modules into a Rete.Network.

Internal. The DSL front end already ran at compile time inside each defrule. What is left at build time is the part that depends on the whole set of rules:

Rete.Compiler.Negation   rewrite compound negations into helper productions
disambiguate_codes/1     qualify an expression code two modules disagree on
Rete.Compiler.BetaGraph  build the beta nodes, sharing them where possible
Rete.Network             group conditions into alpha nodes, index the taxonomy

Node sharing is why this cannot happen per rule. Whether two conditions collapse onto one node depends on what every other rule already put in the graph.

Cross-module expression codes. A code is equal exactly when two expressions behave the same — with one hole. An unqualified call hashes as the bare name. So two modules that each define ok?/1 differently produce the same code for {:bar, amt} when ok?(amt).

Rete.DSL.Codegen clears Rete.IR.Expr's :share for such an expression, while the AST and the caller's environment are still in hand. This qualifies a code the front end did not mark shared, and that more than one module contributed, as <code>@<module>, before building anything from it.

Everything else is shared across modules, because nothing left in it can differ. Aliases resolve to the module they name, @x carries its defining module, and a pin is unwrapped — all before hashing. See docs/design/ir.md §5. So two modules that write {:customer, cid} match it once per fact, not once each.

Sharing within a module is untouched. Getting a cross-module share wrong is silent corruption, so :share defaults to false and only a positive answer shares.