dpl: enhance initial snap

[gudeh]

Summary

This PR modifies the initial snapping performed by the Negotiation legalizer at DPL. With these modifications we attempt to avoid issues coming from other tools.

Issues and motivations:

• RSZ may introduce new instances on top of macros which require snapping to the closest valid row.
• MPL may create vertical/horizontal small channels with only a few sites/rows.
  • In addition, a small space may be crowded with fixed instances. Which is usually the case around macros (endcaps).
• GPL may place top-level (regionless) instances inside regions.

New behavior for initial snapping:

• Use standalone diamond search for closer snapping.
• Snap after site capacity is calculated to account for fixed instances. Do not snap to fixed instances positions (capacity == 0).
• Snap after regions are initiated. Consider instance regions properly with NegotiationLegalizer::respectsFence(). Previous behavior did not account for top-level instances.

Type of Change

• New feature

Impact

Avoid other tools generated issues.

Old and new behavior on the upf_aes test. Previously, top-level (regionless) instances were only snapped out of the regions at the very end, by the diamond search fallback, once negotiation had failed to find valid positions for them.

Now we snap them first, so negotiation can make the necessary moves properly and account more fairly for the competition for space, since all top-level instances are present from the start.

Also, now we avoid bad snappings like this one:

Now we allow diagonal snapping such as these:

Verification

• I have verified that the local build succeeds (./etc/Build.sh).
• I have run the relevant tests and they pass.
• My code follows the repository's formatting guidelines.
• I have signed my commits (DCO).

Related Issues

This branch includes changes from #11089, and should be merged after it.

This PR addresses issues:

• A private design failing on master CI.
• Solves https://github.com/The-OpenROAD-Project-private/OpenROAD-flow-scripts/issues/1772
• Solves region issue at OR test with upf_aes.tcl for PR gpl: min tile congestion inflation  #10977
• I did not test, but I expect this to fix issue [DPL-0701] NegotiationLegalizer did not fully converge on ispd15 mgc_superblue12 #10951.

[gemini-code-assist]

Code Review

This pull request refactors the NegotiationLegalizer by centralizing the snapping logic of movable cells into a new initialSnap() method, and updates how cell padding is handled during negotiation. Feedback on the changes highlights two potential issues in the new initialSnap() method: a potential out-of-bounds array access if the grid height is smaller than the cell height, and a potential signed integer overflow when doubling the search budget.

[gemini-code-assist]

If grid_h_ is less than cell.height (e.g., in extremely small grids or with exceptionally tall cells), grid_h_ - cell.height will be negative. Passing a negative value to GridY and then to gridYToDbu will result in an out-of-bounds array access, causing undefined behavior or a crash. Consider guarding this calculation to ensure a non-negative row index is used.

Suggested change

	const int max_budget
	= grid_w_ * site_width_
	+ std::max(init_y_dbu - dpl_grid->gridYToDbu(GridY{0}).v,
	dpl_grid->gridYToDbu(GridY{grid_h_ - cell.height}).v
	- init_y_dbu);
	const int max_budget
	= grid_w_ * site_width_
	+ std::max(init_y_dbu - dpl_grid->gridYToDbu(GridY{0}).v,
	(grid_h_ >= cell.height)
	? dpl_grid->gridYToDbu(GridY{grid_h_ - cell.height}).v - init_y_dbu
	: 0);

[gemini-code-assist]

If max_budget is very large (e.g., in extremely large designs), budget * 2 can exceed INT_MAX, leading to signed integer overflow (undefined behavior in C++). If it overflows to a negative value, std::min will select the negative value, potentially causing an infinite loop. Capping the budget before multiplying avoids this potential overflow.

Suggested change

	for (int budget = site_width_; !found;
	budget = std::min(budget * 2, max_budget)) {
	for (int budget = site_width_; !found;
	budget = (budget > max_budget / 2) ? max_budget : budget * 2) {