This module implements an inter-procedural, context-sensitive, summary-based points-to analysis for C code.

The analysis determines the set of abstract memory locations that each pointer variable could point to at any given program point. This is a foundational analysis required for many subsequent static analyses, such as taint tracking.

The core algorithm works as follows: 1. **AST Traversal**: It first traverses the Abstract Syntax Tree (AST) of the entire program to find all function definitions and declarations. 2. **Worklist Algorithm**: It uses a worklist algorithm to iteratively analyze functions until a fixed point is reached. The worklist contains pairs of (FunctionName, Context), ensuring that functions are re-analyzed if their calling context changes. 3. **Intra-procedural Analysis**: For each function, it performs a standard forward dataflow analysis over its Control Flow Graph (CFG). The state (or "facts") at each point is a PointsToMap, which maps abstract locations to the set of locations they point to. 4. **Function Summaries**: After analyzing a function, it generates a PointsToSummary. This summary captures the function's effect on pointers, including what it returns and what side effects it has on pointers passed as arguments. This is the key to scalability, as it avoids re-analyzing a function's body at every call site. 5. **Context Sensitivity**: The analysis is context-sensitive, meaning it can distinguish between different call sites of the same function. The Context is a list of node IDs (hashes) representing the call stack. This allows for more precise summaries and handling of recursion. 6. **Fixed-Point Iteration**: The worklist algorithm continues until the summaries for all functions stabilize (i.e., no longer change). When a function's summary changes, all of its callers are added back to the worklist to be re-analyzed with the updated information. This process guarantees that the analysis correctly handles complex interactions, including mutual recursion.