Add usage-based business plan types (#15934)

## Summary
- add `self_serve_business_usage_based` and `enterprise_cbp_usage_based`
to the public/internal plan enums and regenerate the app-server + Python
SDK artifacts
- map both plans through JWT login and backend rate-limit payloads, then
bucket them with the existing Team/Business entitlement behavior in
cloud requirements, usage-limit copy, tooltips, and status display
- keep the earlier display-label remap commit on this branch so the new
Team-like and Business-like plans render consistently in the UI

## Testing
- `just write-app-server-schema`
- `uv run --project sdk/python python
sdk/python/scripts/update_sdk_artifacts.py generate-types`
- `just fix -p codex-protocol -p codex-login -p codex-core -p
codex-backend-client -p codex-cloud-requirements -p codex-tui -p
codex-tui-app-server -p codex-backend-openapi-models`
- `just fmt`
- `just argument-comment-lint`
- `cargo test -p codex-protocol
usage_based_plan_types_use_expected_wire_names`
- `cargo test -p codex-login usage_based`
- `cargo test -p codex-backend-client usage_based`
- `cargo test -p codex-cloud-requirements usage_based`
- `cargo test -p codex-core usage_limit_reached_error_formats_`
- `cargo test -p codex-tui plan_type_display_name_remaps_display_labels`
- `cargo test -p codex-tui remapped`
- `cargo test -p codex-tui-app-server
plan_type_display_name_remaps_display_labels`
- `cargo test -p codex-tui-app-server remapped`
- `cargo test -p codex-tui-app-server
preserves_usage_based_plan_type_wire_name`

## Notes
- a broader multi-crate `cargo test` run still hits unrelated existing
guardian-approval config failures in
`codex-rs/core/src/config/config_tests.rs`

codex-rs/protocol/src/account.rs

@@ -13,9 +13,66 @@ pub enum PlanType {
     Plus,
     Pro,
     Team,
+    #[serde(rename = "self_serve_business_usage_based")]
+    #[ts(rename = "self_serve_business_usage_based")]
+    SelfServeBusinessUsageBased,
     Business,
+    #[serde(rename = "enterprise_cbp_usage_based")]
+    #[ts(rename = "enterprise_cbp_usage_based")]
+    EnterpriseCbpUsageBased,
     Enterprise,
     Edu,
     #[serde(other)]
     Unknown,
 }
+
+impl PlanType {
+    pub fn is_team_like(self) -> bool {
+        matches!(self, Self::Team | Self::SelfServeBusinessUsageBased)
+    }
+
+    pub fn is_business_like(self) -> bool {
+        matches!(self, Self::Business | Self::EnterpriseCbpUsageBased)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::PlanType;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn usage_based_plan_types_use_expected_wire_names() {
+        assert_eq!(
+            serde_json::to_string(&PlanType::SelfServeBusinessUsageBased)
+                .expect("self-serve business usage based should serialize"),
+            "\"self_serve_business_usage_based\""
+        );
+        assert_eq!(
+            serde_json::to_string(&PlanType::EnterpriseCbpUsageBased)
+                .expect("enterprise cbp usage based should serialize"),
+            "\"enterprise_cbp_usage_based\""
+        );
+        assert_eq!(
+            serde_json::from_str::<PlanType>("\"self_serve_business_usage_based\"")
+                .expect("self-serve business usage based should deserialize"),
+            PlanType::SelfServeBusinessUsageBased
+        );
+        assert_eq!(
+            serde_json::from_str::<PlanType>("\"enterprise_cbp_usage_based\"")
+                .expect("enterprise cbp usage based should deserialize"),
+            PlanType::EnterpriseCbpUsageBased
+        );
+    }
+
+    #[test]
+    fn plan_family_helpers_group_usage_based_variants_with_existing_plans() {
+        assert_eq!(PlanType::Team.is_team_like(), true);
+        assert_eq!(PlanType::SelfServeBusinessUsageBased.is_team_like(), true);
+        assert_eq!(PlanType::Business.is_team_like(), false);
+
+        assert_eq!(PlanType::Business.is_business_like(), true);
+        assert_eq!(PlanType::EnterpriseCbpUsageBased.is_business_like(), true);
+        assert_eq!(PlanType::Team.is_business_like(), false);
+    }
+}