Narrow down cast operators on IntType

Say for USHORT, we were implementing casts from and to unsigned.
With this change, we cast from and to uint16_t only.  This allows
compiler more opportunities to catch possible narrowing issues in
the code.

It needed a couple of fixes in the codebase though, because
previously, if a USHORT was participating in arithmetic with signed
numbers, eg. "u + 1", the result would have been unsigned.  With
this change, it would be signed.  The correct fix is to update the
code to read "u + 1u".

That said, I think about conditionally adding back the cast
out to signed/unsigned, to facilitate better type deduction.
But I couldn't think of a real situation where that would help
with anything.  So I didn't add.  Here's what it was:

  template <typename Type2 = hb_conditional<hb_is_signed (Type), signed, unsigned>,
           hb_enable_if (sizeof (Type) < sizeof (Type2))>
  operator hb_type_identity_t<Type2> () const { return v; }

https://github.com/harfbuzz/harfbuzz/pull/2875

src/hb-open-type.hh

diff --git a/src/hb-open-type.hh b/src/hb-open-type.hh
index 0671079..1af4e6e 100644
--- a/src/hb-open-type.hh
+++ b/src/hb-open-type.hh
@@ -54,16 +54,15 @@
 
 /* Integer types in big-endian order and no alignment requirement */
 template <typename Type,
-	  unsigned int Size = sizeof (Type),
-	  typename Wide = hb_conditional<hb_is_signed (Type), signed, unsigned>>
+	  unsigned int Size = sizeof (Type)>
 struct IntType
 {
   typedef Type type;
 
   IntType () = default;
-  explicit constexpr IntType (Wide V) : v {V} {}
-  IntType& operator = (Wide i) { v = i; return *this; }
-  operator Wide () const { return v; }
+  explicit constexpr IntType (Type V) : v {V} {}
+  IntType& operator = (Type i) { v = i; return *this; }
+  operator Type () const { return v; }
 
   bool operator == (const IntType &o) const { return (Type) v == (Type) o.v; }
   bool operator != (const IntType &o) const { return !(*this == o); }